Subversion Repositories DIN Is Noise

/*

* countries.cc

* DIN Is Noise is copyright (c) 2006-2025 Jagannathan Sampath

* DIN Is Noise is released under GNU Public License 2.0

* For more information, please visit https://dinisnoise.org/

*/

#include "countries.h"

#include "vector2d.h"

#include "console.h"

#include "log.h"

#include <vector>

#include <fstream>

#include <algorithm>

using namespace std;

extern string user_data_dir;

extern string country_data_dir;

extern console cons;

bool area::operator< (const area& rhs) const {

 return num_vertices > rhs.num_vertices;

}

countries::countries () {

  name = "Countries";

  id = -1;

  p_cur_country = 0;

  area_id = 0;

  change_curve_name = 1;

}

countries::~countries () {

  widget_save ("d_countries", ctrls);

  save_params ();

}

void countries::load_params () {

  ifstream f (make_fname().c_str(), ios::in);

  string ignore;

  float step;

  f >> ignore >> id >> ignore >> area_id >> ignore >> step;

  pt.step.set_value (step);

  load_country (index[id]);

}

void countries::save_params () {

  ofstream f (make_fname().c_str(), ios::out);

  if (f) {

    f << "id " << id << endl;

    f << "area_id " << area_id << endl;

    f << "step " << int(pt.step.value) << endl;

  }

}

void countries::load_index () {

  string fname (country_data_dir + "index");

  ifstream f (fname.c_str(), ios::in);

  if (!f) {

    dlog << "couldnt read from : " << fname << endl;

    return;

  }

  f >> num_countries;

  index.resize (num_countries);

  for (int i = 0; i < num_countries; ++i) {

    f >> fname;

    index[i] = fname;

  }

  sort (index.begin (), index.end());

}

void countries::setup () {

  plugin::setup ();

  load_index ();

  widget* _ctrls [] = {&ol_country, &ol_area,  &lf_search, &pt.step, &pt.start, &pt.end, &close};

  for (int i = 0; i < 7; ++i) {

    ctrls.push_back (_ctrls[i]);

  }

  num_ctrls = ctrls.size ();

  //for (int i = 0; i < num_ctrls; ++i) ctrls[i]->set_moveable(1);

  lf_search.set_text ("Country?");

  lf_search.set_listener (this);

  lf_search.fld.expr = 0;

  ol_country.set_text ("Country = ");

  ol_country.set_listener (this);

  ol_country.set_click_repeat (1);

  ol_area.set_listener (this);

  ol_area.set_click_repeat (1);

  ol_area.set_text ("Area = ");

  pt.start.set ("Start", 1, 1, MILLION, this, 0);

  pt.end.set ("End", 1, 1, MILLION, this, 0);

  pt.step.set ("Step", 1, 1, MILLION, this, 0);

  close.set_text ("Close");

  close.set_listener (&cll);

  widget_load ("d_countries", ctrls);

  load_params ();

  lf_search.fld.set_text (index[id]);

}

void countries::render () {

  if (p_cur_country) {

    points.clear ();

    area& a0 = p_cur_country->areas[area_id];

    int start = pt.start.value;

    float a0x = a0.x[start], a0y = a0.y[start];

    point<float> pa0 (a0x, a0y);

    points.push_back (pa0);

    for (int i = start + 1, j = pt.end.value, di = pt.step.value; i < j; i += di) points.push_back (point<float>(a0.x[i], a0.y[i]));

    if (close.state || (points.size () == 1)) points.push_back (pa0);

    gen_pts ();

    ss.str("");

    ss << p_cur_country->name;

  }

}

country* countries::load_country (const string& which) {

  country& c = the_countries [which];

  if (c.num_areas ==  0) {

    string fname (country_data_dir + which);

    ifstream f (fname.c_str(), ios::in);

    if (!f) {

      dlog << "couldnt load from : " << fname << endl;

      return 0;

    }

    c.name = which;

    string ignore;

    while (!f.eof()) {

      f >> ignore >> c.num_areas;

      for (int i = 0; i < c.num_areas; ++i) {

        c.areas.push_back (area());

        area& ai = c.areas[i];

        f >> ignore >> ai.num_vertices;

        float l, b, r, t; f >> ignore >> l >> b >> r >> t;

        ai.bbox (l, b, r, t);

        /*dlog << "name = " << c.name << " ratio = " << ai.bbox.width * 1.0 / ai.bbox.height << endl;

        float fac = ai.bbox.width * 1.0 / ai.bbox.height - 1.0;*/

        int& q = ai.num_vertices;

        int n1 = q + 1;

        ai.x.resize (n1);

        ai.y.resize (n1);

        for (int p = 0; p < q; ++p) f >> ai.x[p] >> ai.y[p];

        ai.x[q] = ai.x[0];

        ai.y[q] = ai.y[0];

        ++q;

      }

    }

  }

  p_cur_country = &c;

  set_country (which);

  return &c;

}

void countries::picked (label& lbl, int dir) {

  if (&lbl == &ol_country.option) {

    id += dir;

    if (id < 0) id = num_countries - 1; else if (id >= num_countries) id = 0;

    string name (index[id]);

    load_country (name);

  } else if (&lbl == &ol_area.option) {

    if (p_cur_country) {

      area_id += dir;

      render_area ();

    }

  }

}

void countries::changed (field& f) {

  if (&f == &lf_search.fld) {

    string name (f.text);

    for (int i = 0, j = name.size (); i < j; ++i) if (name[i] == ' ') name[i]= '_';

    int nid = find_id (name);

    if (nid == -1) {

      cons << RED << "Couldnt find " << name << eol;

      if (name == "") f.set_text (index[id]);

    } else {

      id = nid;

      load_country (name);

    }

  } else {

    render ();

    if (cb_auto_apply.state) clicked (b_apply);

  }

}

void countries::render_area () {

  if (area_id < 0) area_id = p_cur_country->num_areas - 1; else if (area_id >= p_cur_country->num_areas) area_id = 0;

  stringstream ss; ss << "Area " << (area_id+1) << " of " << p_cur_country->num_areas;

  ol_area.set_text (ss.str());

  int n_1 = p_cur_country->areas[area_id].num_vertices - 1;

  pt.start.set_limits (0, n_1);

  pt.end.set_limits (0, n_1);

  pt.start.set_value (0);

  pt.end.set_value (n_1);

  render ();

  if (cb_auto_apply.state) clicked (b_apply);

}

void countries::set_country (const string& name) {

  ol_country.set_text (name);

  lf_search.set_text (name);

  area_id = 0;

  render_area ();

}

int countries::find_id (const string& name) {

  for (int i = 0, j = index.size (); i < j; ++i) if (index[i] == name) return i;

  return -1;

}

void countries::closer::changed (checkbutton& cb) {

  extern countries countries_;

  countries_.do_render ();

}

void area::calc_bbox () {

  if (num_vertices) {

    float xmin = x[0], ymin = y[0];

    float xmax = xmin, ymax = ymin;

    for (int i = 1, j = num_vertices; i < j; ++i) {

      float xi = x[i], yi = y[i];

      if (xi < xmin) xmin = xi; else if (xi > xmax) xmax = xi;

      if (yi < ymin) ymin = yi; else if (yi > ymax) ymax = yi;

    }

    bbox (xmin, ymin, xmax, ymax);

  }

}

void area::normalise () {

  float aspect_ratio = bbox.width * 1. / bbox.height;

  float xw = aspect_ratio * 2.0f, xwh = xw / 2.0f;

  for (int i = 0, j = num_vertices; i < j; ++i) {

    float xi = x[i], yi = y[i];

    float fx = (xi - bbox.left) * bbox.width_1;

    float fy = (yi - bbox.bottom) * bbox.height_1;

    float xj = -xwh + fx * xw;

    float yj = -1 + fy * 2.0f;

    x[i] = xj;

    y[i] = yj;

  }

  bbox (-xwh, -1.0f, xwh, 1.0f);

}