#pragma once

#ifndef T_SEGMENTADJUSTER_H

#define T_SEGMENTADJUSTER_H

#include "tgeometry.h"

#include "tstroke.h"

#undef DVAPI

#undef DVVAR

#ifdef TVECTORIMAGE_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

#ifdef _WIN32

#pragma warning(disable : 4251)

#endif

/*!

  The TSegmentAdjuster minimizes the distance between

     stroke0->getPoint(w0) and stroke1->getPoint(w1)

  changing the values of w0 and w1 (in a defined range).

  Usage:

  TSegmentAdjuster::End p0(stroke0, w0, 0, 1);

  TSegmentAdjuster::End p1(stroke1, w1, 0, 1);

  TSegmentAdjuster adjuster;

  adjuster.compute(p0,p1);

  // the adjusted segment is p0.getPoint(), p1.getPoint()

  if you want to adjust the segment only in the w-growing-direction:

  TSegmentAdjuster::End p0(stroke0, w0, w0, 1);

  TSegmentAdjuster::End p1(stroke1, w1, w1, 1);

  TSegmentAdjuster adjuster;

  adjuster.compute(p0,p1);

 */

class DVAPI TSegmentAdjuster {

public:

  class End {

  public:

    TStroke *m_stroke;

    double m_w;

    double m_wmin, m_wmax;

    End() : m_stroke(0), m_w(0), m_wmin(0), m_wmax(1) {}

    End(TStroke *stroke, double w)

        : m_stroke(stroke), m_w(w), m_wmin(0), m_wmax(1) {}

    End(TStroke *stroke, double w, double wmin, double wmax)

        : m_stroke(stroke), m_w(w), m_wmin(wmin), m_wmax(wmax) {}

    TPointD getPoint() const { return m_stroke->getPoint(m_w); }

    TPointD getSpeed() const { return m_stroke->getSpeed(m_w); }

  };

  TSegmentAdjuster();

  // debug

  void enableTrace(bool enabled) { m_traceEnabled = enabled; }

  void draw();

  void clear() { m_links.clear(); }

  void compute(End &a, End &b);

private:

  End m_a, m_b, m_c, m_d;

  std::vector<std::pair<tpointd, tpointd="">> m_links;</std::pair<tpointd,>

  bool m_traceEnabled;

  inline double fun(double u, double v) const {

    return norm2(m_a.m_stroke->getPoint(u) - m_b.m_stroke->getPoint(v));

  }

  inline void gradient(double &dfdu, double &dfdv, double u, double v) {

    const double h = 0.0001;

    dfdu           = (fun(u + h, v) - fun(u - h, v)) / (2 * h);

    dfdv           = (fun(u, v + h) - fun(u, v - h)) / (2 * h);

  }

  inline static double dsda(TStroke *stroke, double w, double dwda) {

    const double h = 0.0001;

    return norm(stroke->getPoint(w + dwda * h) -

                stroke->getPoint(w - dwda * h)) /

           (2 * h);

  }

};

//---------------------------------------------------------------------------------------

#endif  // T_SEGMENTADJUSTER_H