Пример #1
0
PRIVATE     VOID
sel_palette(int blocks, int distinct, struct rgb *my_color_pt)
{
    int         boxes;
    /*  int i, j; */
    struct box *ptr;

    init(blocks, distinct, my_color_pt);

    /* split box into smaller boxes with about equal number of points */
    for (boxes = 1; boxes < PALSIZE; boxes++)
      {
          /*
             ptr=frontier->right;
             j = 0;
             while (ptr != NULL)
             {
             printf("Box %d, distinct %d, total %d\n",j,ptr->nmbr_distinct,
             ptr->nmbr_pts);
             for (i=0; i<ptr->nmbr_distinct; i++)
             printf("pt %d: %d %d %d",i,distinct_pt[ptr->pts[i]].c[RED],
             distinct_pt[ptr->pts[i]].c[GREEN],
             distinct_pt[ptr->pts[i]].c[BLUE]);
             j++;
             ptr = ptr->right;
             }
           */

          ptr = find_box();
          split_box(ptr);
      }

    assign_color();
}
void Vision::get_array(int faces[6][9])
{

  Mat image0;
  Mat image1;
  Mat image2;
  Mat image3;

  Mat filtered, denoised;


  {
  VideoCapture cap0(0);
  //cap0.set(CV_CAP_PROP_BRIGHTNESS, CAMERA_BRIGHTNESS);
  //cap0.set(CV_CAP_PROP_CONTRAST, CAMERA_CONTRAST);
  cap0.set(CV_CAP_PROP_SATURATION, CAMERA_SATURATION);
  //cap0.set(CV_CAP_PROP_CONTRAST, CAMERA_CONTRAST);
  /*
  cap0.set(CV_CAP_PROP_BRIGHTNESS, CAMERA_BRIGHTNESS);

  cap0.set(CV_CAP_PROP_HUE, CAMERA_HUE);
  cap0.set(CV_CAP_PROP_GAIN, CAMERA_GAIN);
  cap0.set(CV_CAP_PROP_EXPOSURE, CAMERA_EXPOSURE);
  */
  cap0 >> image0;
    //imshow("Image 0", image0);

  }


  {
  VideoCapture cap1(1);
  //cap1.set(CV_CAP_PROP_BRIGHTNESS, CAMERA_BRIGHTNESS);
  //cap1.set(CV_CAP_PROP_CONTRAST, CAMERA_CONTRAST);
  cap1.set(CV_CAP_PROP_SATURATION, CAMERA_SATURATION);
  /*
  cap1.set(CV_CAP_PROP_BRIGHTNESS, CAMERA_BRIGHTNESS);
  cap1.set(CV_CAP_PROP_CONTRAST, CAMERA_CONTRAST);
  cap1.set(CV_CAP_PROP_HUE, CAMERA_HUE);
  cap1.set(CV_CAP_PROP_GAIN, CAMERA_GAIN);
  cap1.set(CV_CAP_PROP_EXPOSURE, CAMERA_EXPOSURE);
  */
  cap1 >> image1;
  //imshow("Image 1", image1);

  }


  {

  VideoCapture cap2(2);
  cap2.set(CV_CAP_PROP_SATURATION, CAMERA_SATURATION);
  //cap2.set(CV_CAP_PROP_BRIGHTNESS, CAMERA_BRIGHTNESS);
  //cap2.set(CV_CAP_PROP_CONTRAST, CAMERA_CONTRAST);
  /*
  cap2.set(CV_CAP_PROP_HUE, CAMERA_HUE);
  cap2.set(CV_CAP_PROP_GAIN, CAMERA_GAIN);
  cap2.set(CV_CAP_PROP_EXPOSURE, CAMERA_EXPOSURE);
  */
  cap2 >> image2;
  /*imshow("Image 2", image2);
  bilateralFilter(image2, filtered, 3, 75, 75, BORDER_DEFAULT);
  imshow("Filtered", filtered);
  fastNlMeansDenoisingColored(filtered, denoised, 3, 10, 7, 21);
  imshow("Denoised", denoised);*/
  }


  {
  VideoCapture cap3(3);
  //cap3.set(CV_CAP_PROP_BRIGHTNESS, CAMERA_BRIGHTNESS);
  //cap3.set(CV_CAP_PROP_CONTRAST, CAMERA_CONTRAST);
  cap3.set(CV_CAP_PROP_SATURATION, CAMERA_SATURATION);
  /*

  cap3.set(CV_CAP_PROP_HUE, CAMERA_HUE);
  cap3.set(CV_CAP_PROP_GAIN, CAMERA_GAIN);
  cap3.set(CV_CAP_PROP_EXPOSURE, CAMERA_EXPOSURE);
  */
  cap3 >> image3;
  //imshow("Image 3", image3);
 // waitKey(1);
  }




  //all this stuff gets manually filled out
  std::cout <<"Image 0" << std::endl;
  faces[0][1] = assign_color( image0, 363, 62);
  faces[0][2] = assign_color( image0, 293, 94);
  faces[0][5] = assign_color( image0, 227, 58);
  faces[2][0] = assign_color( image0, 330, 156);
  faces[2][1] = assign_color( image0, 395, 114);
  faces[2][2] = assign_color( image0, 445, 85);
  faces[2][3] = assign_color( image0, 327, 235);
  faces[2][6] = assign_color( image0, 321, 293);
  faces[4][0] = assign_color( image0, 140, 94);
  faces[4][1] = assign_color( image0, 193, 119);
  faces[4][2] = assign_color( image0, 256, 156);
  faces[4][5] = assign_color( image0, 265, 237);
  faces[4][8] = assign_color( image0, 270, 294);
/*
  std::cout <<"Image 0 Modified" << std::endl;
  faces[0][1] = assign_color( denoised, 363, 62, 0);
  faces[0][2] = assign_color( denoised, 293, 94, 0);
  faces[0][5] = assign_color( denoised, 227, 58, 0);
  faces[2][0] = assign_color( denoised, 330, 156, 0);
  faces[2][1] = assign_color( denoised, 395, 114, 0);
  faces[2][2] = assign_color( denoised, 445, 85, 0);
  faces[2][3] = assign_color( denoised, 327, 235, 0);
  faces[2][6] = assign_color( denoised, 321, 293, 0);
  faces[4][0] = assign_color( denoised, 140, 94, 0);
  faces[4][1] = assign_color( denoised, 193, 119, 0);
  faces[4][2] = assign_color( denoised, 256, 156, 0);
  faces[4][5] = assign_color( denoised, 265, 237, 0);
  faces[4][8] = assign_color( denoised, 270, 294, 0);
*/

  std::cout << "Image 1" << std::endl;
  faces[3][0] = assign_color( image1, 313, 282 );
  faces[3][1] = assign_color( image1, 319, 227 );
  faces[3][2] = assign_color( image1, 324, 152);
  faces[3][5] = assign_color( image1, 388, 110);
  faces[3][8] = assign_color( image1, 441, 68);
  faces[4][3] = assign_color( image1, 216, 49);
  faces[4][6] = assign_color( image1, 286, 86);
  faces[4][7] = assign_color( image1, 358, 51);
  faces[5][2] = assign_color( image1, 138, 79 );
  faces[5][5] = assign_color( image1, 187, 111 );
  faces[5][6] = assign_color( image1, 259, 282 );
  faces[5][7] = assign_color( image1, 257, 226 );
  faces[5][8] = assign_color( image1, 250, 150);

  std::cout << "Image 2" << std::endl;
  faces[0][0] = assign_color( image2, 191, 13);
  faces[0][3] = assign_color( image2, 246, 47);
  faces[0][6] = assign_color( image2, 320, 81);
  faces[0][7] = assign_color( image2, 385, 45);
  faces[0][8] = assign_color( image2, 422, 19);
  faces[1][0] = assign_color( image2, 163, 73);
  faces[1][1] = assign_color( image2, 216, 111);
  faces[1][2] = assign_color( image2, 284, 149);
  faces[1][5] = assign_color( image2, 287, 224);
  faces[1][8] = assign_color( image2, 288, 278);
  faces[5][0] = assign_color( image2, 356, 148);
  faces[5][1] = assign_color( image2, 420, 103);
  faces[5][3] = assign_color( image2, 349, 224);


  std::cout << "Image 3" << std::endl;
  faces[1][3] = assign_color( image3, 219, 50);
  faces[1][6] = assign_color( image3, 291, 93 );
  faces[1][7] = assign_color( image3, 360, 51 );
  faces[2][5] = assign_color( image3, 182, 109 );
  faces[2][7] = assign_color( image3, 249, 228 );
  faces[2][8] = assign_color( image3, 252, 155 );
  faces[3][3] = assign_color( image3, 385, 109 );
  faces[3][6] = assign_color( image3, 324, 151 );
  faces[3][7] = assign_color( image3, 313, 227 );


  for (int v = 0; v < 6; v++)
  {
      faces[v][4] = v;
  }
 /*
  for (int d = 0; d < 6; d++)
  {
      for (int o = 0; o < 9; o++)
      {
          sum[ faces[d][o] ] += 1;
      }
  }


  for (int h = 0; h < 6; h++)
  {
      if (sum[h] != 9)
      {
            //std::cerr << "Color reading error..." << std::endl;
      }
  }
  */


}
Пример #3
0
void TextImpl::update_vertices() {
    int offset = 0;
    int position_x = tile_size * m_pos_x;
    int position_y = tile_size * m_pos_y;

    if (m_stack != NULL) {
        position_x += m_stack->m_pos_x;
        position_y += m_stack->m_pos_y;
    }

    float factor = 76.35f;
    //int factor = 75;

    for (unsigned int i = 0; i < m_length; ++i) {
        char c = m_str[i];
        sf::Vertex* quad = &m_vertices[(std::size_t) i * 4];

        switch(c) {
            case ' ':
                quad[0].position = sf::Vector2f(0, 0);
                quad[1].position = sf::Vector2f(0, 0);
                quad[2].position = sf::Vector2f(0, 0);
                quad[3].position = sf::Vector2f(0, 0);

                offset += 30.0f * tile_size / factor;
                break;

            case '\'':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (31.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (31.0f * tile_size / factor), position_y + (int) (37.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (37.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(34.0f, 0.0f);
                quad[1].texCoords = sf::Vector2f(65.0f, 0.0f);
                quad[2].texCoords = sf::Vector2f(65.0f, 37.0f);
                quad[3].texCoords = sf::Vector2f(34.0f, 37.0f);
                offset += 26.0f * tile_size / factor;
                break;

            case '?':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(334.0f, 81.0f);
                quad[1].texCoords = sf::Vector2f(407.0f, 81.0f);
                quad[2].texCoords = sf::Vector2f(407.0f, 162.0f);
                quad[3].texCoords = sf::Vector2f(334.0f, 162.0f);
                offset += 68.0f * tile_size / factor;
                break;

            case '!':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (32.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (32.0f * tile_size / factor), position_y + (int) (80.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (80.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(0.0f, 0.0f);
                quad[1].texCoords = sf::Vector2f(32.0f, 0.0f);
                quad[2].texCoords = sf::Vector2f(32.0f, 80.0f);
                quad[3].texCoords = sf::Vector2f(0.0f, 80.0f);
                offset += 27.0f * tile_size / factor;
                break;

            case '.':
                quad[0].position = sf::Vector2f(position_x + offset, position_y + (int) (48.0f * tile_size / factor));
                quad[1].position = sf::Vector2f(position_x + offset + (int) (31.0f * tile_size / factor), position_y + (int) (48.0f * tile_size / factor));
                quad[2].position = sf::Vector2f(position_x + offset + (int) (31.0f * tile_size / factor), position_y + (int) (80.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (80.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(34.0f, 48.0f);
                quad[1].texCoords = sf::Vector2f(65.0f, 48.0f);
                quad[2].texCoords = sf::Vector2f(65.0f, 80.0f);
                quad[3].texCoords = sf::Vector2f(34.0f, 80.0f);
                offset += 26.0f * tile_size / factor;
                break;

            case ',':
                quad[0].position = sf::Vector2f(position_x + offset, position_y + (int) (42.0f * tile_size / factor));
                quad[1].position = sf::Vector2f(position_x + offset + (int) (30.0f * tile_size / factor), position_y + (int) (42.0f * tile_size / factor));
                quad[2].position = sf::Vector2f(position_x + offset + (int) (30.0f * tile_size / factor), position_y + (int) (85.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (85.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(477.0f, 44.0f);
                quad[1].texCoords = sf::Vector2f(507.0f, 44.0f);
                quad[2].texCoords = sf::Vector2f(507.0f, 81.0f);
                quad[3].texCoords = sf::Vector2f(477.0f, 81.0f);
                offset += 25.0f * tile_size / factor;
                break;

            case ':':
                quad[0].position = sf::Vector2f(position_x + offset, position_y + (int) (24.0f * tile_size / factor));
                quad[1].position = sf::Vector2f(position_x + offset + (int) (33.0f * tile_size / factor), position_y + (int) (24.0f * tile_size / factor));
                quad[2].position = sf::Vector2f(position_x + offset + (int) (33.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(300.0f, 105.0f);
                quad[1].texCoords = sf::Vector2f(333.0f, 105.0f);
                quad[2].texCoords = sf::Vector2f(333.0f, 162.0f);
                quad[3].texCoords = sf::Vector2f(300.0f, 162.0f);
                offset += 28.0f * tile_size / factor;
                break;

            case '0':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (80.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (80.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(66.0f, 0.0f);
                quad[1].texCoords = sf::Vector2f(140.0f, 0.0f);
                quad[2].texCoords = sf::Vector2f(140.0f, 80.0f);
                quad[3].texCoords = sf::Vector2f(66.0f, 80.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case '1':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (32.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (32.0f * tile_size / factor), position_y + (int) (80.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (80.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(141.0f, 0.0f);
                quad[1].texCoords = sf::Vector2f(173.0f, 0.0f);
                quad[2].texCoords = sf::Vector2f(173.0f, 80.0f);
                quad[3].texCoords = sf::Vector2f(141.0f, 80.0f);
                offset += 27.0f * tile_size / factor;
                break;

            case '2':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (80.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (80.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(175.0f, 0.0f);
                quad[1].texCoords = sf::Vector2f(249.0f, 0.0f);
                quad[2].texCoords = sf::Vector2f(249.0f, 80.0f);
                quad[3].texCoords = sf::Vector2f(175.0f, 80.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case '3':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y + (int) (80.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (80.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(251.0f, 0.0f);
                quad[1].texCoords = sf::Vector2f(324.0f, 0.0f);
                quad[2].texCoords = sf::Vector2f(324.0f, 80.0f);
                quad[3].texCoords = sf::Vector2f(251.0f, 80.0f);
                offset += 68.0f * tile_size / factor;
                break;

            case '4':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (80.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (80.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(325.0f, 0.0f);
                quad[1].texCoords = sf::Vector2f(400.0f, 0.0f);
                quad[2].texCoords = sf::Vector2f(400.0f, 80.0f);
                quad[3].texCoords = sf::Vector2f(325.0f, 80.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case '5':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (80.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (80.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(401.0f, 0.0f);
                quad[1].texCoords = sf::Vector2f(475.0f, 0.0f);
                quad[2].texCoords = sf::Vector2f(475.0f, 80.0f);
                quad[3].texCoords = sf::Vector2f(401.0f, 80.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case '6':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(0.0f, 81.0f);
                quad[1].texCoords = sf::Vector2f(75.0f, 81.0f);
                quad[2].texCoords = sf::Vector2f(75.0f, 162.0f);
                quad[3].texCoords = sf::Vector2f(0.0f, 162.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case '7':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(76.0f, 81.0f);
                quad[1].texCoords = sf::Vector2f(150.0f, 81.0f);
                quad[2].texCoords = sf::Vector2f(150.0f, 162.0f);
                quad[3].texCoords = sf::Vector2f(76.0f, 162.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case '8':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(225.0f, 81.0f);
                quad[1].texCoords = sf::Vector2f(151.0f, 81.0f);
                quad[2].texCoords = sf::Vector2f(151.0f, 162.0f);
                quad[3].texCoords = sf::Vector2f(225.0f, 162.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case '9':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(226.0f, 81.0f);
                quad[1].texCoords = sf::Vector2f(300.0f, 81.0f);
                quad[2].texCoords = sf::Vector2f(300.0f, 162.0f);
                quad[3].texCoords = sf::Vector2f(226.0f, 162.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'A':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(408.0f, 81.0f);
                quad[1].texCoords = sf::Vector2f(483.0f, 81.0f);
                quad[2].texCoords = sf::Vector2f(483.0f, 162.0f);
                quad[3].texCoords = sf::Vector2f(408.0f, 162.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case 'B':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(0.0f, 162.0f);
                quad[1].texCoords = sf::Vector2f(75.0f, 162.0f);
                quad[2].texCoords = sf::Vector2f(75.0f, 243.0f);
                quad[3].texCoords = sf::Vector2f(0.0F, 243.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case 'C':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(76.0f, 162.0f);
                quad[1].texCoords = sf::Vector2f(149.0f, 162.0f);
                quad[2].texCoords = sf::Vector2f(149.0f, 243.0f);
                quad[3].texCoords = sf::Vector2f(76.0f, 243.0f);
                offset += 68.0f * tile_size / factor;
                break;

            case 'D':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(150.0f, 162.0f);
                quad[1].texCoords = sf::Vector2f(224.0f, 162.0f);
                quad[2].texCoords = sf::Vector2f(224.0f, 243.0f);
                quad[3].texCoords = sf::Vector2f(150.0f, 243.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'E':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (71.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (71.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(225.0f, 162.0f);
                quad[1].texCoords = sf::Vector2f(296.0f, 162.0f);
                quad[2].texCoords = sf::Vector2f(296.0f, 243.0f);
                quad[3].texCoords = sf::Vector2f(225.0f, 243.0f);
                offset += 66.0f * tile_size / factor;
                break;

            case 'F':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (68.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (68.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(297.0f, 162.0f);
                quad[1].texCoords = sf::Vector2f(365.0f, 162.0f);
                quad[2].texCoords = sf::Vector2f(365.0f, 243.0f);
                quad[3].texCoords = sf::Vector2f(297.0f, 243.0f);
                offset += 63.0f * tile_size / factor;
                break;

            case 'G':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(366.0f, 162.0f);
                quad[1].texCoords = sf::Vector2f(441.0f, 162.0f);
                quad[2].texCoords = sf::Vector2f(441.0f, 243.0f);
                quad[3].texCoords = sf::Vector2f(366.0f, 243.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case 'H':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(0.0f, 243.0f);
                quad[1].texCoords = sf::Vector2f(75.0f, 243.0f);
                quad[2].texCoords = sf::Vector2f(75.0f, 324.0f);
                quad[3].texCoords = sf::Vector2f(0.0f, 324.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case 'I':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (31.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (31.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(76.0f, 243.0f);
                quad[1].texCoords = sf::Vector2f(107.0f, 243.0f);
                quad[2].texCoords = sf::Vector2f(107.0f, 324.0f);
                quad[3].texCoords = sf::Vector2f(76.0f, 324.0f);
                offset += 26.0f * tile_size / factor;
                break;

            case 'J':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(109.0f, 243.0f);
                quad[1].texCoords = sf::Vector2f(182.0f, 243.0f);
                quad[2].texCoords = sf::Vector2f(182.0f, 324.0f);
                quad[3].texCoords = sf::Vector2f(109.0f, 324.0f);
                offset += 68.0f * tile_size / factor;
                break;

            case 'K':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(183.0f, 243.0f);
                quad[1].texCoords = sf::Vector2f(256.0f, 243.0f);
                quad[2].texCoords = sf::Vector2f(256.0f, 324.0f);
                quad[3].texCoords = sf::Vector2f(183.0f, 324.0f);
                offset += 68.0f * tile_size / factor;
                break;

            case 'L':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(258.0f, 243.0f);
                quad[1].texCoords = sf::Vector2f(332.0f, 243.0f);
                quad[2].texCoords = sf::Vector2f(332.0f, 324.0f);
                quad[3].texCoords = sf::Vector2f(258.0f, 324.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'M':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (99.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (99.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(333.0f, 243.0f);
                quad[1].texCoords = sf::Vector2f(432.0f, 243.0f);
                quad[2].texCoords = sf::Vector2f(432.0f, 324.0f);
                quad[3].texCoords = sf::Vector2f(333.0f, 324.0f);
                offset += 94.0f * tile_size / factor;
                break;

            case 'N':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(434.0f, 243.0f);
                quad[1].texCoords = sf::Vector2f(508.0f, 243.0f);
                quad[2].texCoords = sf::Vector2f(508.0f, 324.0f);
                quad[3].texCoords = sf::Vector2f(434.0f, 324.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'O':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(0.0f, 325.0f);
                quad[1].texCoords = sf::Vector2f(75.0f, 325.0f);
                quad[2].texCoords = sf::Vector2f(75.0f, 406.0f);
                quad[3].texCoords = sf::Vector2f(0.0f, 406.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case 'P':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(76.0f, 325.0f);
                quad[1].texCoords = sf::Vector2f(150.0f, 325.0f);
                quad[2].texCoords = sf::Vector2f(150.0f, 406.0f);
                quad[3].texCoords = sf::Vector2f(76.0f, 406.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'Q':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (85.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (85.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(151.0f, 325.0f);
                quad[1].texCoords = sf::Vector2f(225.0f, 325.0f);
                quad[2].texCoords = sf::Vector2f(225.0f, 410.0f);
                quad[3].texCoords = sf::Vector2f(151.0f, 410.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'R':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(226.0f, 325.0f);
                quad[1].texCoords = sf::Vector2f(300.0f, 325.0f);
                quad[2].texCoords = sf::Vector2f(300.0f, 406.0f);
                quad[3].texCoords = sf::Vector2f(226.0f, 406.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'S':
                quad[0].position = sf::Vector2f(position_x + offset + (int) (-3.0f * tile_size / factor), position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset + (int) (-3.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(301.0f, 325.0f);
                quad[1].texCoords = sf::Vector2f(375.0f, 325.0f);
                quad[2].texCoords = sf::Vector2f(375.0f, 406.0f);
                quad[3].texCoords = sf::Vector2f(301.0f, 406.0f);
                offset += 67.0f * tile_size / factor;
                break;

            case 'T':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(376.0f, 325.0f);
                quad[1].texCoords = sf::Vector2f(450.0f, 325.0f);
                quad[2].texCoords = sf::Vector2f(450.0f, 406.0f);
                quad[3].texCoords = sf::Vector2f(376.0f, 406.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'U':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(0.0f, 411.0f);
                quad[1].texCoords = sf::Vector2f(75.0f, 411.0f);
                quad[2].texCoords = sf::Vector2f(75.0f, 492.0f);
                quad[3].texCoords = sf::Vector2f(0.0f, 492.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case 'V':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (74.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(76.0f, 411.0f);
                quad[1].texCoords = sf::Vector2f(150.0f, 411.0f);
                quad[2].texCoords = sf::Vector2f(150.0f, 492.0f);
                quad[3].texCoords = sf::Vector2f(76.0f, 492.0f);
                offset += 69.0f * tile_size / factor;
                break;

            case 'W':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (107.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (107.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(151.0f, 411.0f);
                quad[1].texCoords = sf::Vector2f(258.0f, 411.0f);
                quad[2].texCoords = sf::Vector2f(258.0f, 492.0f);
                quad[3].texCoords = sf::Vector2f(151.0f, 492.0f);
                offset += 102.0f * tile_size / factor;
                break;

            case 'X':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(259.0f, 411.0f);
                quad[1].texCoords = sf::Vector2f(334.0f, 411.0f);
                quad[2].texCoords = sf::Vector2f(334.0f, 492.0f);
                quad[3].texCoords = sf::Vector2f(259.0f, 492.0f);
                offset += 70.0f * tile_size / factor;
                break;

            case 'Y':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (73.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(336.0f, 411.0f);
                quad[1].texCoords = sf::Vector2f(409.0f, 411.0f);
                quad[2].texCoords = sf::Vector2f(409.0f, 492.0f);
                quad[3].texCoords = sf::Vector2f(336.0f, 492.0f);
                offset += 68.0f * tile_size / factor;
                break;

            case 'Z':
                quad[0].position = sf::Vector2f(position_x + offset, position_y);
                quad[1].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y);
                quad[2].position = sf::Vector2f(position_x + offset + (int) (75.0f * tile_size / factor), position_y + (int) (81.0f * tile_size / factor));
                quad[3].position = sf::Vector2f(position_x + offset, position_y + (int) (81.0f * tile_size / factor));

                quad[0].texCoords = sf::Vector2f(410.0f, 411.0f);
                quad[1].texCoords = sf::Vector2f(485.0f, 411.0f);
                quad[2].texCoords = sf::Vector2f(485.0f, 492.0f);
                quad[3].texCoords = sf::Vector2f(410.0f, 492.0f);
                offset += 70.0f * tile_size / factor;
                break;
        }
    }

    assign_color();
}
Пример #4
0
void TextImpl::update_color(int8_t color) {
    if (m_color != color) {
        m_color = color;
        assign_color();
    }
}