GlyphMap.cpp

//
//  GlyphMap.cpp
//  xwall
//
//  Created by Tim Medcalf on 19/04/2011.
//  Copyright 2011 ErgoThis Ltd. All rights reserved.
//

#include "GlyphMap.h"
#include "Global.h"
#include "Rect.h"

GlyphMap::GlyphMap(string glyph) : _glyph(glyph)
{
  scan_glyph();
  rects = new vector<Rect*>;
  create_rects();
}

GlyphMap::~GlyphMap()
{
  for(vector<Rect*>::iterator itG = rects->begin(); itG < rects->end(); itG++)
  {
    delete *itG;
  }
  delete rects;
}

void GlyphMap::set(int x, int y)
{
  if ((x >= settings.glyph_map_width) || (y >= settings.glyph_map_height))
  {
    cout << "Error - invalid coordinates sent to glyphmap" << endl;
    exit(EXIT_FAILURE);
  }
  bits[x + (settings.glyph_map_width * y)] = 1;
}


void GlyphMap::clear(int x,int y)
{
  if ((x >= settings.glyph_map_width) || (y >= settings.glyph_map_height))
  {
    cout << "Error - invalid coordinates sent to glyphmap" << endl;
    exit(EXIT_FAILURE);
  }
  bits[x + (settings.glyph_map_width * y)] = 0;
}

bool GlyphMap::val(int x, int y)
{
  if ((x >= settings.glyph_map_width) || (y >= settings.glyph_map_height))
  {
    cout << "Error - invalid coordinates sent to glyphmap" << endl;
    exit(EXIT_FAILURE);
  }
  return bits[x + (settings.glyph_map_width * y)];
}

int GlyphMap::width()
{
  return settings.glyph_map_width;
}

int GlyphMap::height()
{
  return settings.glyph_map_height;  
}


void GlyphMap::scan_glyph()
{
  //create the cairo surfaces
  cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 0,0);
 	cairo_t *cr = cairo_create(surface);
  cairo_select_font_face (cr, settings.font.c_str(), settings.font_style, settings.font_weight);
  cairo_set_font_size(cr,settings.font_size);
  cairo_text_extents(cr,_glyph.c_str(),&_letter_te);
  
  //draw the letter so its top left is at 0,0
  cairo_move_to(cr,0 - _letter_te.x_bearing, 0 -_letter_te.y_bearing);
  cairo_text_path(cr,_glyph.c_str());
  
  //work out the values to map the mapping to pixel dimensions
  double xmodifier = _letter_te.width / (double) width();
  double ymodifier = _letter_te.height / (double) height();
  //loop through the map's columns and rows
  for (int mapX = 0; mapX < width(); mapX++)
  {
    for (int mapY = 0; mapY < height(); mapY++)
    {
      //now we need to loop through all the pixels that this area maps to to check if there's anything "active" in this box
      for (double pixelX = (mapX * xmodifier); pixelX < ((mapX + 1) * xmodifier); pixelX++) 
      {
        for (double pixelY = (mapY * ymodifier); pixelY < ((mapY + 1) * ymodifier); pixelY++)
        {
          if (cairo_in_fill(cr, pixelX, pixelY))
          {
            set(mapX,mapY);
            break;
          }
        }
        if (val(mapX,mapY)) break;
      }
    }
  }
  cairo_destroy(cr);
  cairo_surface_destroy(surface);
  //test_output();
}

//scan down the 
void GlyphMap::create_rects()
{
  bool clear = false;
  while (!clear)
  {
    clear = true;
    for (int x = 0; x < width(); x++)
    {
      for (int y = 0; y < height(); y++)
      {
        if (val(x,y))
        {
          clear = false;
          scan_rect(x,y);
        }
      }
    }
  }
}

void GlyphMap::scan_rect(int start_x, int start_y)
{
  if (!val(start_x,start_y)) return;
  
  int tl_x = start_x;
  int tl_y = start_y;
  
  int br_x = start_x;
  int br_y = start_y;
  
  
  //can we go lower?
  while ( (br_y < (height()-1)) && (val(br_x,br_y +1))) br_y++;
  
  
  //so we've got the lowest point we can go downwards
  //now, can we go wider?
  bool valid = true;
  while ((br_x < (width()-1)) && valid)
  {
    for (int tmpy = tl_y; tmpy <= br_y; tmpy++)
    {
      if (!val(br_x+1,tmpy))
      {
        valid = false;
        break;
      }
    }
    if (valid) br_x++;
  }
  
  
  //okay now we should have width and height of a rect...
  //lets create a Rect object to store it
  Rect *newRect = new Rect((tl_x)*10,(tl_y)*10, ((br_x - tl_x) + 1) * 10, ((br_y - tl_y) + 1) * 10,false,0);
  rects->push_back(newRect);
  
  //now lets clear the rects in this section
  for (int i = tl_x; i<= br_x; i++)
  {
    for (int j = tl_y; j<= br_y; j++)
    {
      clear(i, j);
    }
  }
  //test_output();
}


void GlyphMap::test_output()
{
  cout << endl;
  cout << _glyph.c_str() << endl;
  for (int row = 0; row < height(); row++)
  {
    for (int col = 0; col < width(); col++)
    {
      val(col,row) ? cout << "*" : cout << " ";
    }
    cout << endl;
  }
}