¿Cómo comparar y clasificar gráficos de radar (araña)?

Question

Decir que tengo un montón de gráficos de radar, ¿cómo puedo comparar?

Lo que quiero hacer es 'rango' un montón de gráficos de araña por su 'cobertura'. Cada cuadro es un Pentagonal araña gráfico.

Mi primera idea fue comparar las áreas, ya que la cobertura es, pero no hay una fórmula fácil para hacerlo.

Uno que conozco es $$ S = \frac{p \estrella r} 2 $$

where $ r $ is the radius of an inscribed circle and $ p $ es el perímetro del pentágono.

El problema con esto es que usted no puede realmente hacer (o al menos yo no sé cómo hacerlo) que con los datos en bruto como este

1 0.1
2 0.98
3 0.53
4 0.01
5 0.6

donde la primera columna es el "vértice" de la tabla y la segunda columna es el punto de dibujar en el gráfico. Los puntos siempre estará entre 0 y 1.

Algo como esto

Así que me preguntaba, ¿hay una mejor manera de comparar araña/gráficos de radar?

Answer 1

La siguiente secuencia de comandos (debería) calcula el área de la cobertura según los puntos en las líneas desde el origen del circuncírculo hasta los vértices.

La idea es calcular las áreas de cada triángulo en cada cuadrante y devolver la suma.

Esto no es una respuesta completa. Sólo como un guión de 'ayudante'.

 #include <vector>
#include <numeric>
#include <iostream>
#include <tuple>
#include <cmath>

double area_of_a_triangle (double base, double height) {

  return (0.5 * base * height);

}

double area_of_spider_chart (std::vector<double> list_of_points) {

  double angle_of_triangles = (360 / list_of_points.size()) * 0.0174533;
  // angle between each sides in radians

  std::vector<std::tuple<double, double>> sides_pairs;
  // stores paris of two sides of each triangle in each quadrant of the spider chart.
  // angle between each sides would be equal to "angle_of_triangles"

  double areas = 0;
  // stores the areas of each triangle

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

  // Following generates pairs of sides

  for (unsigned short i = 0; i < list_of_points.size() - 1; i++) {

    sides_pairs.push_back(std::make_tuple(list_of_points[i], list_of_points[i + 1]));

  }

  sides_pairs.push_back(std::make_tuple(list_of_points[list_of_points.size() - 1], list_of_points[0]));

  // Pairs generation complete

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

  // Following calculates area of triangle from given pairs

  for (auto x : sides_pairs) {

    double base_of_triangle = 0;
    double smaller_side_of_triangle = 0;

    // making sure base is the longer one just to keep it clean
    if (std::get<0>(x) > std::get<1>(x)) {

      base_of_triangle = std::get<0>(x);
      smaller_side_of_triangle = std::get<1>(x);

      }
    else {

      base_of_triangle = std::get<1>(x);
      smaller_side_of_triangle = std::get<0>(x);
    }


    auto height_of_triangle = std::sin(angle_of_triangles) * smaller_side_of_triangle;

    areas += area_of_a_triangle(base_of_triangle, height_of_triangle);

  }

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

  return areas;
  // returns area of the "coverage" in SpiderChart

}

int main () {

  std::vector<double> input = {1, 1, 1, 1, 1, 1};

  std::cout << area_of_spider_chart(input) << std::endl;

  // this returns area of hexagon with circumcircle radius of 1

}