Subversion Repositories DIN Is Noise

/*

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

#include "vector2d.h"

#include "ui_list.h"

#include "console.h"

#include <vector>

#include <fstream>

using namespace std;

fractaliser::fractaliser () : seed ("seed.crv"), ed ("seed.ed"), lib ("seed.lib") {

  name = "Fractaliser";

  ed.add (&seed, &lis);

  ed.attach_library (&lib);

  threshold = 0;

  back_ed = 0;

  load_params ();

}

fractaliser::~fractaliser () {

  seed.save ("seed.crv");

  widget_save ("d_fractaliser", ctrls);

  save_params ();

}

void fractaliser::load_params () {

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

  string ignore;

  f >> ignore >> threshold;

}

void fractaliser::save_params () {

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

  string ignore;

  f << "threshold " << sp_threshold.value << endl;

}

void fractaliser::setup () {

  plugin::setup ();

  widget* _ctrls [] = {&sp_threshold, &cd_seed, &ab_left, &ab_right, &l_seed, &b_edit, &b_mirror, &sp_scale};

  for (int i = 0; i < 8; ++i) ctrls.push_back (_ctrls[i]);

  num_ctrls = ctrls.size ();

  sp_threshold.set ("Threshold", 0.01f, 0, MILLION, 0, 0);

  sp_threshold.set_value (threshold);

  sp_scale.set ("Scale", 0.01f, -MILLION, MILLION, 0, 0);

  sp_scale.set_value (1.0f);

  l_seed.set_text ("Seed");

  b_edit.set_text ("Edit");

  b_mirror.set_text ("Flip");

  cd_seed.crv = &seed;

  cd_seed.unit_bbox ();

  ab_left.set_dir (arrow_button::left);

  ab_right.set_dir (arrow_button::right);

  ab_left.click_repeat = 1;

  ab_right.click_repeat = 1;

  widget_load ("d_fractaliser", ctrls);

  button* btn [] = {&ab_left, &ab_right, &b_edit, &b_mirror};

  for (int i = 0; i < 4; ++i) btn[i]->set_listener (this);

}

void fractaliser::clicked (button& b) {

  if (&b == &ab_left) {

    ed.win.calc ();

    ed.load_curve (-1);

    render ();

  } else if (&b == &ab_right) {

    ed.win.calc ();

    ed.load_curve (+1);

    render ();

  } else if (&b == &b_edit) {

    if (b_edit.text == "Edit") {

      b_edit.set_text ("Go back");

      back_ed = uis.crved;

      uis.set_current (&ed);

    } else {

      uis.set_current (back_ed);

      b_edit.set_text ("Edit");

    }

  } else if (&b == &b_mirror) {

    ed.get_picked_curve ();

    int whole_curve = 1;

    ed.mirror (whole_curve);

  } else plugin::clicked (b);

}

void fractaliser::render () {

  // replace all segments of input curve with seed curve

  //

  curve_editor* ed = uis.crved;

  multi_curve& in = *ed->get_picked_curve (); // apply seed curve on this input curve

  vector<crvpt> in_pts;

  int n = in.get_profile_points (in_pts); // get curve profile

  if (n < 2) {

    cons << RED << "not enough points on curve!" << eol;

    return;

  }

  int m = n - 1;

  points.clear ();

  left_tangents.clear ();

  right_tangents.clear ();

  threshold = sp_threshold.value;

  points_array sv = seed.vertices;

  points_array slt = seed.left_tangents;

  points_array srt = seed.right_tangents;

  int q = sv.size () - 1;

  scale_seed_curve (sv, slt, srt, q+1, sp_scale.value);

  point<float>& rt0 = srt[0];

  point<float>& ltq = slt[q];

  float dx=0, dy=0, pdx=0, pdy=0;

  crvpt vk;

  int subdivided=0;

  for (int i = 0; i < m; ++i) { // replace all segments of input curve with seed curve

    crvpt& vi = in_pts [i];  // ith vertex

    int j = i + 1;

    crvpt& vj = in_pts[j]; // jth vertex

    points.push_back (point<float>(vi.x, vi.y));

    if (i == 0) left_tangents.push_back (point<float>(vi.x, vi.y));

    else {

      if (subdivided)

        left_tangents.push_back (point<float>(vk.x + ltq.x * dx + ltq.y * pdx, vk.y + ltq.x * dy + ltq.y * pdy));

      else

        left_tangents.push_back (point<float>(vi.x, vi.y));

    }

    dx = vj.x - vi.x; dy = vj.y - vi.y; // find vector joining i and j vertex

    pdx = -dy; pdy = dx; // find perpendiular vector (ie y-axis) to vector joining i and j vertices (ie x-axis)

    double length = magnitude (dx, dy); // find length of this vector

    subdivided = 0;

    if (length >= threshold) { // replace vector joining vertices with seed curve

      subdivided = 1;

      right_tangents.push_back (point<float>(vi.x + rt0.x * dx + rt0.y * pdx, vi.y + rt0.x * dy + rt0.y * pdy)); // = right tangent of seed curve's 1st vertex

      for (int p = 1; p < q; ++p) { // go thru the seed curve and replace

        // get a point of seed curve

        point<float>& pt = sv[p];

        point<float>& plt = slt[p];

        point<float>& prt = srt[p];

        // compute output by going along x-axis and y-axis vectors from input 

        // using x and y amounts from seed curve

        point<float> ov (vi.x + pt.x * dx + pt.y * pdx, vi.y + pt.x * dy + pt.y * pdy);

        point<float> olt (vi.x + plt.x * dx + plt.y * pdx, vi.y + plt.x * dy + plt.y * pdy);

        point<float> ort (vi.x + prt.x * dx + prt.y * pdx, vi.y + prt.x * dy + prt.y * pdy);

        // add vertex, left and right tangent to output curve

        points.push_back (ov);

        left_tangents.push_back (olt);

        right_tangents.push_back (ort);

      }

    } else right_tangents.push_back (point<float> (vi.x, vi.y));   

    vk = vi;

  }

  crvpt& mv = in_pts[m];

  crvpt& mv1 = in_pts[m-1];

  points.push_back (point<float>(mv.x, mv.y));

  if (subdivided)

    left_tangents.push_back (point<float>(mv1.x + ltq.x * dx + ltq.y * pdx, mv1.y + ltq.x * dy + ltq.y * pdy));

  else

    left_tangents.push_back (point<float>(mv.x, mv.y));

  right_tangents.push_back (point<float>(mv.x, mv.y));

  ss.str("");

  ss << in.name << "_" << seed.name;

}

void fractaliser::draw (curve_editor* ed) {}

void fractaliser::scale_seed_curve (points_array& v, points_array& lt, points_array& rt, int n, float scale) {

  // we only scale in y, because x is normalised from 0 to 1 and cant be changed

  point<float> o; // origin at 0,0

  points_array* pa[3] = {&v, &lt, &rt};

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

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

      points_array& p = *pa[j];

      point<float>& pi = p[i];

      point<float> dp; direction (dp, o, pi);

      dp.y *= scale;

      pi = o + dp;

    }

  }

}