#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