Subversion Repositories DIN Is Noise

/*

* multi_curve.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 "multi_curve.h"

#include "vector2d.h"

#include "container.h"

#include "random.h"

#include "log.h"

#include <iostream>

extern string user_data_dir;

static const char eol = '\n';

multi_curve::multi_curve (const string& filename) {

  load (filename);

}

multi_curve::multi_curve () {

  clear ();

}

void multi_curve::clear (int all) {

  if (all) {

    name = "nameless";

    set_color (1, 1, 1);

  }

  vertices.clear ();

  num_vertices = 0;

  last_vertex = -1;

  left_tangents.clear ();

  right_tangents.clear ();

  curv.clear ();

  limit = 0.001f;

  shapeform = 0;

}

//

// must call following 3 funcs together with add_vertex called first

// to correctly add curve

//

void multi_curve::add_vertex (float x, float y, int p) {

  last_vertex = num_vertices++;

  vertices.push_back (pointinfo<float> (x, y, p));

  if (num_vertices > 1) {

    curv.push_back (curve());

    ncurvs = curv.size ();

  }

}

void multi_curve::add_left_tangent (float x, float y, int p) {

  left_tangents.push_back (pointinfo<float> (x, y, p));

}

void multi_curve::add_right_tangent (float x, float y, int p) {

  right_tangents.push_back (pointinfo<float> (x, y, p));

}

void multi_curve::get_vertex (int i, float& x, float& y) {

  pointinfo<float>& v = vertices[i];

  x = v.x;

  y = v.y;

}

int multi_curve::set_vertex (int i, float x, float y) {

  pointinfo<float>& v = vertices[i];

  if ((v.x != x) || (v.y != y)) {

    pointinfo<float>& lt = left_tangents[i];

    if (lt.pin == 0) {

      float dlx, dly;

      dlx = lt.x - v.x;

      dly = lt.y - v.y;

      lt.x = x + dlx; lt.y = y + dly;

    }

    pointinfo<float>& rt = right_tangents[i];

    if (rt.pin == 0) {

      float drx, dry;

      drx = rt.x - v.x; dry = rt.y - v.y;

      rt.x = x + drx; rt.y = y + dry;

    }

    v.x = x;

    v.y = y;

    if (i < ncurvs) curv[i].eval = 1;

    int i_1 = i - 1; if (i_1 > -1) curv[i_1].eval = 1;

    return 1;

  } else return 0;

}

int multi_curve::set_left_tangent (int i, float x, float y) {

  point<float>& lt = left_tangents [i];

  if ((lt.x != x) || (lt.y != y)) {

    lt.x = x;

    lt.y = y;

    int j = i - 1;

    if (j > -1) curv[j].eval = 1;

    return 1;

  }

  return 0;

}

int multi_curve::set_right_tangent (int i, float x, float y) {

  point<float>& rt = right_tangents[i];

  if ((rt.x != x) || (rt.y != y)) {

    rt.x = x;

    rt.y = y;

    if (i < ncurvs) curv[i].eval = 1;

    return 1;

  }

  return 0;

}

void multi_curve::get_left_tangent (int i, float& x, float& y) {

  point<float>& lt = left_tangents [i];

  x = lt.x;

  y = lt.y;

}

void multi_curve::get_right_tangent (int i, float& x, float& y) {

  point<float>& rt = right_tangents[i];

  x = rt.x;

  y = rt.y;

}

int multi_curve::insert (float x, float y, float tx, float ty) {

  point<float>& vl = vertices[last_vertex];

  if (x > vl.x) { // append

    add_vertex (x, y);

    add_left_tangent (x, y);

    add_right_tangent (x, y);

    evaluate ();

    return 1;

  }

  // insert

  //

  points_array::iterator \

    vter = ++vertices.begin (), \

    lter = ++left_tangents.begin (), \

    rter = ++right_tangents.begin ();

  vector<curve>::iterator cter = curv.begin ();

  for (int i = 0, k = last_vertex; i < k; ++i, ++vter, ++lter, ++rter, ++cter) {

    point<float>& vi = vertices[i];

    point<float>& vj = vertices[i + 1];

    if ((x >= vi.x) && (x <= vj.x)) {

      point<float> v (x, y);

      vertices.insert (vter, v);

      last_vertex = num_vertices++;

      left_tangents.insert (lter, v);

      right_tangents.insert (rter, v);

      (*cter).eval = 1;

      curv.insert (cter, curve());

      ++ncurvs;

      return 1;

    }

  }

  return 0;

}

int multi_curve::remove (int i) {

  // remove ith vertex and its tangents

  if (num_vertices < 3) return 0;

  erase_id (vertices, i);

  erase_id (left_tangents, i);

  erase_id (right_tangents, i);

  if (i == ncurvs) {

    int j = i - 1;

    erase_id (curv, j);

  } else {

    erase_id (curv, i);

    if (--i > -1) curv[i].eval = 1; else curv[0].eval = 1;

  }

  --num_vertices;

  --ncurvs;

  last_vertex = num_vertices - 1;

  return 1;

}

void multi_curve::set_limit (float d) {

  limit = d;

  require_eval ();

}

void multi_curve::require_eval () {

  for (int i = 0; i < ncurvs; ++i) curv[i].eval = 1;

}

void multi_curve::set_color () {

  static const float base = 0.1f;

  static rnd<float> rd (base, 1.0f - base);

  r = rd (); g = rd (); b = rd ();

  calc_tangent_color ();

}

void multi_curve::set_color (float rr, float gg, float bb) {

  r = rr;

  g = gg;

  b = bb;

  calc_tangent_color ();

}

void multi_curve::calc_tangent_color () {

  static const float factor = 0.5;

  rt = factor * r;

  gt = factor * g;

  bt = factor * b;

}

void multi_curve::evaluate () {

  int nevals = 0;

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

    curve& crv = curv[i];

    if (crv.eval) {

      int j = i + 1;

      point<float>& v0 = vertices[i];

      point<float>& v1 = vertices[j];

      point<float>& rt0 = right_tangents[i];

      point<float>& lt1 = left_tangents[j];

      crv.vertex (0, v0.x, v0.y);

      crv.vertex (1, v1.x, v1.y);

      crv.tangent (0, rt0.x, rt0.y);

      crv.tangent (1, lt1.x, lt1.y);

      crv.set_limit (limit);

      crv.evaluate (shapeform);

      ++nevals;

    }

  }

  if (nevals) {

    if (shapeform) {

      float total_length = 0.0f;

      float now_length = 0.0f;

      for (int i = 0; i < ncurvs; ++i) total_length += curv[i].length;

      for (int i = 0; i < ncurvs; ++i) curv[i].normalise_length (now_length, total_length);

      check_shapeform ();

    }

  }

}

void multi_curve::check_shapeform () {

  for (int i = 0, j = 1, k = ncurvs - 1; i < k; ++i, ++j) {

    curve& crvi = curv[i];

    curve& crvj = curv[j];

    vector<crvpt>& dptsi = crvi.dpts;

    vector<crvpt>& dptsj = crvj.dpts;

    int last = dptsi.size () - 1;

    crvpt& dl = dptsi[last];

    crvpt& d0 = dptsj[0];

    d0.x = dl.x;

    d0.y = dl.y;

  }

}

void multi_curve::calc_bbox (box<float>& b) {

  if (ncurvs) {

    int num_points = curv[0].vpts.size ();

    if (num_points) {

      const vector<crvpt>& vpts = curv[0].vpts;

      b.left = b.right = vpts[0].x;

      b.bottom = b.top = vpts[0].y;

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

        const vector <crvpt>& vpts = curv[i].vpts;

        num_points = vpts.size ();

        for (int j = 0; j < num_points; ++j) {

          const crvpt& p = vpts[j];

          if (p.x < b.left) b.left = p.x; else if (p.x > b.right) b.right = p.x;

          if (p.y < b.bottom) b.bottom = p.y; else if (p.y > b.top) b.top = p.y;

        }

      }

    }

  }

  b.calc ();

}

void multi_curve::load (const string& filename) {

  ifstream file ((user_data_dir + filename).c_str (), ios::in);

  if (!file) {

    dlog << "!!! failed to load curve from: " << filename << " !!!" << endl;

    return;

  }

  load (file);

  dlog << "+++ loaded curve from: " << filename << " +++" << endl;

}

void multi_curve::load (ifstream& file) {

  clear ();

  string ignore;

  file >> ignore >> name;

  int nvertices;

  file >> ignore >> nvertices;

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

    float x, y;

    int p;

    file >> ignore >> x >> y >> p;

    add_vertex (x, y, p);

    file >> ignore >> x >> y >> p;

    add_left_tangent (x, y, p);

    file >> ignore >> x >> y >> p;

    add_right_tangent (x, y, p);

  }

  file >> ignore >> limit;

  float ir, ig, ib; file >> ignore >> ir >> ig >> ib;

  set_color (ir, ig, ib);

  file >> ignore >> shapeform;

  setcentroid (shapeform);

  point<float>& lt0 = left_tangents[0];

  point<float>& v0 = vertices[0];

  int last = nvertices - 1;

  point<float>& rtl = right_tangents[last];

  point<float>& vl = vertices[last];

  lt0.x = v0.x; lt0.y = v0.y;

  rtl.x = vl.x; rtl.y = vl.y;

  evaluate ();

}

void multi_curve::save (const string& filename) {

  ofstream file ((user_data_dir + filename).c_str (), ios::out);

  if (!file) {

    dlog << "!!! failed writing curve to: " << filename << endl;

    return;

  }

  save (file);

  dlog << "+++ saved curve into: " << filename << " +++" << endl;

}

void multi_curve::save (ofstream& file) {

  string ignore;

  if (name == "") name = "nameless";

  file << "name " << name << eol;

  file << "num_vertices " << num_vertices << eol;

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

    pointinfo<float>& v = vertices[i];

    pointinfo<float>& lt = left_tangents[i];

    pointinfo<float>& rt = right_tangents[i];

    file << "v" << i << spc << v.x << spc << v.y << spc << v.pin << eol;

    file << "lt" << i << spc << lt.x << spc << lt.y << spc << lt.pin << eol;

    file << "rt" << i << spc << rt.x << spc << rt.y << spc << rt.pin << eol;

  }

  file << "limit " << limit << eol;

  file << "color " << r << spc << g << spc << b << eol;

  file << "shapeform " << shapeform << eol;

}

void create_polyline (multi_curve& crv, const points_array& pts) {

  int npts = pts.size ();

  if (npts < 2) return;

  crv.clear (0);

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

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

    crv.add_vertex (xi, yi);

    crv.add_left_tangent (xi, yi);

    crv.add_right_tangent (xi, yi);

  }

  crv.evaluate ();

}

void convert2_polyline (multi_curve& crv) {

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

    point<float>& v = crv.vertices[i];

    crv.set_left_tangent (i, v.x, v.y);

    crv.set_right_tangent (i, v.x, v.y);

  }

  crv.evaluate ();

}

void convert2_catmull_rom (multi_curve& crv, float tangent_size) {

  int npts = crv.num_vertices;

  if (npts < 2) return;

  int last = npts - 1;

  point<float>& p0 = crv.vertices[0];

  point<float>& p1 = crv.vertices[1];

  point<float>& pl = crv.vertices[last];

  point<float>& pl1 = crv.vertices[last-1];

  // set tangents for 1st vertex

  float dx, dy; direction (dx, dy, p0.x, p0.y, p1.x, p1.y);

  float tx = tangent_size * dx, ty = tangent_size * dy;

  crv.set_left_tangent (0, p0.x - tx, p0.y - ty);

  crv.set_right_tangent (0, p0.x + tx, p0.y + ty);

  // set tangents for last vertex

  direction (dx, dy, pl.x, pl.y, pl1.x, pl1.y);

  tx = tangent_size * dx; ty = tangent_size * dy;

  crv.set_left_tangent (last, pl.x + tx, pl.y + ty);

  crv.set_right_tangent (last, pl.x - tx, pl.y - ty);

  // set left, right tangent for inbetween vertices

  for (int i = 1; i < last; ++i) {

    int l = i - 1, r = i + 1;

    point<float>& pi = crv.vertices[i];

    point<float>& pl = crv.vertices[l];

    point<float>& pr = crv.vertices[r];

    direction (dx, dy, pl.x, pl.y, pr.x, pr.y);

    crv.set_left_tangent (i, pi.x - tangent_size * dx, pi.y - tangent_size * dy);

    crv.set_right_tangent (i, pi.x + tangent_size * dx, pi.y + tangent_size * dy);

  }

  crv.evaluate ();

}

multi_curve* check_list (multi_curve** lst, int n, const string& name) {

  for (int m = 0; m < n; ++m) if (lst[m]->name == name) return lst[m];

  return 0;

}

vector<crvpt>& multi_curve::get_profile_points (int i) {

  if (shapeform) return curv[i].dpts; else return curv[i].vpts;

}

void multi_curve::setcentroid (int shapeform) {

  static const float CX [] = {0.0f, 0.5f};

  cen.x = CX [shapeform];

  cen.y = 0.0f;

}

void multi_curve::set_shapeform (int what) {

  shapeform = what;

  setcentroid (shapeform);

  require_eval ();

  evaluate ();

}

void multi_curve::rotate (float angle) {

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

    pointinfo<float>& lt = left_tangents[i];

    if (lt.pin == 0) lt.rotate (cen, angle);

  }

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

    pointinfo<float>& rt = right_tangents[i];

    if (rt.pin == 0) rt.rotate (cen, angle);

  }

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

    pointinfo<float>& vi = vertices[i];

    if (vi.pin == 0) vi.rotate (cen, angle);

  }

  point<float>& v0 = vertices[0];

  point<float>& lt0 = left_tangents[0];

  lt0 = v0;

  point<float>& vl = vertices[last_vertex];

  point<float>& rtl = right_tangents[last_vertex];

  rtl = vl;

  require_eval ();

  evaluate ();

}

void multi_curve::scale (float sx, float sy) {

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

    point<float>& vi = vertices[i];

    point<float>& lt = left_tangents[i];

    point<float>& rt = right_tangents[i];

    vi.scale (cen, sx, sy);

    lt.scale (cen, sx, sy);

    rt.scale (cen, sx, sy);

  }

  require_eval ();

  evaluate ();

}

void multi_curve::get_xy (double d, float& x, float& y) {

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

    curve& c = curv[i];

    vector<crvpt>& vpts = c.vpts;

    vector<crvpt>& dpts = c.dpts;

    for (int m = 0, n = dpts.size () - 1; m < n; ++m) {

      crvpt& dm = dpts[m];

      crvpt& dn = dpts[m+1];

      crvpt& vm = vpts[m];

      crvpt& vn = vpts[m+1];

      if (d >= dm.x && d <= dn.x) {

        float amt = (d - dm.x) / (dn.x - dm.x);

        x = vm.x + amt * (vn.x - vm.x);

        y = vm.y + amt * (vn.y - vm.y);

        return;

      }

    }

  }

}

int multi_curve::get_total_points () {

  int total = 0;

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

    vector<crvpt>& vpts = curv[i].vpts;

    int ni = vpts.size () - 1;

    total = total + ni;

  }

  ++total;

  return total;

}

int multi_curve::get_total_points (vector<int>& crvs) {

  int j = ncurvs, j_1 = j - 1;

  crvs.reserve (j);

  int total = 0;

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

    vector<crvpt>& vpts = curv[i].vpts;

    int ni = vpts.size () - 1;

    crvs[i] = ni;

    total = total + ni;

  }

  ++crvs[j_1];

  ++total;

  return total;

}

int multi_curve::get_profile_points (vector<crvpt>& profile) {

  vector<int> crvs;

  int n = get_total_points (crvs);

  profile.reserve (n);

  profile.clear ();

  for (int i = 0, k = 0; i < ncurvs; ++i) {

    vector<crvpt>& vpts = curv[i].vpts;

    for (int p = 0; p < crvs[i]; ++p) profile[k++] = vpts[p];

  }

  return n;

}

double multi_curve::get_tangent_mag (int i, points_array& pa) {

  point<float>& v = vertices[i];

  point<float>& t = pa[i];

  return magnitude (v.x, v.y, t.x, t.y);

}

double multi_curve::get_left_tangent_mag (int i) {

  return get_tangent_mag (i, left_tangents);

}

double multi_curve::get_right_tangent_mag (int i) {

  return get_tangent_mag (i, right_tangents);

}

void multi_curve::move (float dx, float dy) {

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

    pointinfo<float>& p = vertices [i];

    set_vertex (i, p.x + dx, p.y + dy);

    /*if (p.carry == 0) {

      pointinfo<float>& l = left_tangents [i];

      if (l.pin == 0) set_left_tangent (i, l.x + dx, l.y + dy);

      pointinfo<float>& r = right_tangents [i];

      if (r.pin == 0) set_right_tangent (i, r.x + dx, r.y + dy);

    //}*/

  }

  require_eval ();

  evaluate ();

}

extern void make_good_name (string& name);

void multi_curve::set_name (const string& _name) {

  name = _name;

  make_good_name (name);

}

void scale (point<float>& p, point<float>& c, float sx, float sy) {

  float px = sx * (p.x - c.x), py = sy * (p.y - c.y);

  p.x = c.x + px;

  p.y = c.y + py;

}