Помоги исправить ошибки компиляции. Код на C++ #include "Intersector.h"
#include "Figure.h"
#include <string>

template <typename T>
static inline bool isCircle(T figure)    //static
{
	Circle* circle = dynamic_cast(figure1);
	if (circle != nullptr) {
		return true;
	}
	else {
		return false;
	}
}
template <typename T>

static inline bool isTriangle(T figure)
{
	Triangle* triangle = dynamic_cast(figure1);
	if (triangle != nullptr) {
		return true;
	}
	else {
		return false;
	}
}

template <typename T>
static inline bool isPolygon(T figure)
{
	Polygon* polygon = dynamic_cast(figure1);
	if (polygon != nullptr) {
		return true;
	}
	else {
		return false;
	}
}


template <typename T, typename U> 
inline std::string Intersector<T, U>::Intersect(T figure1, U figure2)
{
	if (isCircle(figure1) == true && isTriangle(figure2) == true)
	{
		if (IntersectCircleWithTriangle(figure1, figure2))
			return "yes";
		else return "no";
	}
	else if (isCircle(figure1) == true && isCircle(figure2) == true)
	{
		if (IntersectCircleWithCircle(figure1, figure2))
			return "yes";
		else return "no";
	}
	else if (isTriangle(figure1) == true && isCircle(figure2) == true)
	{
		if (IntersectCircleWithTriangle(figure2, figure1))
			return "yes";
		else return "no";
	}
	else if (isTriangle(figure1) == true && isTriangle(figure2) == true)
	{
		if (IntersectTriangleWithTriangle(figure1, figure2))
			return "yes";
		else return "no";

	}
	else if (isPolygon(figure1) == true && isPolygon(figure2) == true)
	{
		if (IntersectPolygonWithPolygon(figure1, figure2))
		{
			return "yes";
		}
		else return "no";

	}
	else return "no";
}

template <typename T, typename U>
inline bool Intersector<T, U>::IntersectCircleWithTriangle(Circle a, Triangle b)
{
	double minX = std::min(std::min(b.getP1().x, b.getP2().x), b.getP3().x);
	double maxX = std::max(std::max(b.getP1().x, b.getP2().x), b.getP3().x);
	double minY = std::min(std::min(b.getP1().y, b.getP2().y), b.getP3().y);
	double maxY = std::max(std::max(b.getP1().y, b.getP2().y), b.getP3().y);

	if (a.getCenter().x + a.getRad() < minX || a.getCenter().x - a.getRad() > maxY ||
		a.getCenter().y + a.getRad() < minY || a.getCenter().y - a.getRad() > maxY)
	{
		// Если максимальная проекция круга на оси координат находится полностью вне треугольника,
		// то пересечение отсутствует
		return false;
	}
	//Проверяем пересечение круга и ребер треугольника
	double distance1 = std::abs((b.getP2().y - b.getP1().y) * a.getCenter().x - (b.getP2().x - b.getP1().x) * a.getCenter().y + b.getP2().x * b.getP1().y - b.getP2().y * b.getP1().x) /
		sqrt(pow(b.getP2().y - b.getP1().y, 2) + pow(b.getP2().x - b.getP1().x, 2));

	double distance2 = std::abs((b.getP3().y - b.getP2().y) * a.getCenter().x - (b.getP3().x - b.getP2().x) * a.getCenter().y + b.getP3().x * b.getP2().y - b.getP3().y * b.getP2().x) /
		sqrt(pow(b.getP3().y - b.getP2().y, 2) + pow(b.getP3().x - b.getP2().x, 2));

	double distance3 = std::abs((b.getP1().y - b.getP3().y) * a.getCenter().x - (b.getP1().x - b.getP3().x) * a.getCenter().y + b.getP1().x * b.getP3().y - b.getP1().y * b.getP3().x) /
		sqrt(pow(b.getP1().y - b.getP3().y, 2) + pow(b.getP1().x - b.getP3().x, 2));
	if (distance1 <= a.getRad() || distance2 <= a.getRad() || distance3 <= a.getRad())
	{
		// Если расстояние от центра круга до ребра треугольника меньше или равно радиусу круга,
		// то пересечение есть
		return true;
	}
	else return false;
}

template <typename T, typename U>
inline bool Intersector<T, U>::IntersectCircleWithCircle(Circle a, Circle b)
{
	// Логика проверки пересечения двух кругов
	double distance = sqrt(pow(a.getCenter().x - b.getCenter().x, 2) + pow(a.getCenter().y - b.getCenter().y, 2));
	//Проверяем пересекаются ли два круга
	if (distance <= a.getRad() + b.getRad()) return true;
	else return false;
}

template <typename T, typename U>
inline bool Intersector<T, U>::IntersectTriangleWithTriangle(Triangle a, Triangle b)
{
	Figure::Point p1 = a.getP1();
	Figure::Point p2 = a.getP2();
	Figure::Point p3 = a.getP3();
	Figure::Point p4 = b.getP1();
	Figure::Point p5 = b.getP2();
	Figure::Point p6 = b.getP3();

	// Проверяем пересечение сторон треугольников
	if (CheckEdgeIntersection(a.getP1(), a.getP2(), b.getP1(), b.getP2()) ||
		CheckEdgeIntersection(a.getP1(), a.getP2(), b.getP2(), b.getP3()) ||
		CheckEdgeIntersection(a.getP1(), a.getP2(), b.getP3(), b.getP1()) ||
		CheckEdgeIntersection(a.getP2(), a.getP3(), b.getP1(), b.getP2()) ||
		CheckEdgeIntersection(a.getP2(), a.getP3(), b.getP2(), b.getP3()) ||
		CheckEdgeIntersection(a.getP2(), a.getP3(), b.getP3(), b.getP1()) ||
		CheckEdgeIntersection(a.getP3(), a.getP1(), b.getP1(), b.getP2()) ||
		CheckEdgeIntersection(a.getP3(), a.getP1(), b.getP2(), b.getP3()) ||
		CheckEdgeIntersection(a.getP3(), a.getP1(), b.getP3(), b.getP1()))
	{
		return true;
	}
	else return false;
}

template <typename T, typename U>
inline bool Intersector<T, U>::CheckEdgeIntersection(Figure::Point a, Figure::Point b, Figure::Point c, Figure::Point d)
{
	int o1 = CalculateOrientation(a, b, c);
	int o2 = CalculateOrientation(a, b, d);
	int o3 = CalculateOrientation(c, d, a);
	int o4 = CalculateOrientation(c, d, b);

	if (o1 != o2 && o3 != o4)
	{
		return true;
	}

	return false;
}

template <typename T, typename U>
inline int Intersector<T, U>::CalculateOrientation(Figure::Point p, Figure::Point q, Figure::Point r)
{
	int value = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);

	if (value == 0)
	{
		return 0; // Коллинеарны
	}
	else if (value > 0)
	{
		return 1; // Против часовой стрелки
	}
	else
	{
		return -1; // По часовой стрелке
	}
}


template <typename T, typename U>
inline bool Intersector<T, U>::IntersectPolygonWithPolygon(Polygon a, Polygon b)
{
	vector<Figure::Point> pointsA = new Figures.Point[a.getSize()]; //проверить
	pointsA = a.getPoints();
	vector<Figure::Point> pointsB = new Figures.Point[b.getSize()];
	pointsB = b.getPoints();
	int numPointsA = a.getSize();
	int numPointsB = b.getSize();

	// Проверяем пересечение ребер между многоугольниками
	for (int i = 0; i < numPointsA; i++)
	{
		int nextA = (i + 1) % numPointsA;

		for (int j = 0; j < numPointsB; j++)
		{
			int nextB = (j + 1) % numPointsB;

			if (CheckEdgeIntersection(pointsA[i], pointsA[nextA], pointsB[j], pointsB[nextB]))
			{
				return true;
			}
		}
	}

	// Если ребра не пересекаются, проверяем, содержат ли один многоугольник вершины другого
	for (int i = 0; i < numPointsA; i++)
	{
		if (PointInsidePolygon(pointsA[i], pointsB))
		{
			return true;
		}
	}

	for (int i = 0; i < numPointsB; i++)
	{
		if (PointInsidePolygon(pointsB[i], pointsA))
		{
			return true;
		}
	}

	// Если ни одно условие не выполнилось, многоугольники не пересекаются
	return false;
}
}