fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4.  
  5. typedef struct Vector
  6. {
  7.     double x;
  8.     double y;
  9.     double z;
  10. } Vector;
  11.  
  12. typedef struct Mesh
  13. {
  14.     int a;
  15.     int b;
  16.     int c;
  17. } Mesh;
  18.  
  19. typedef struct Figure
  20. {
  21.     int numPoints;
  22.     Vector *points;
  23.     int numMeshes;
  24.     Mesh *meshes;
  25.     int **boundary;
  26. } Figure;
  27.  
  28. Vector subtract(Vector v1, Vector v2)
  29. {
  30.     Vector v = {v1.x - v2.x, v1.y - v2.y, v1.z - v2.z};
  31.     return v;
  32. }
  33.  
  34. double dot(Vector v1, Vector v2)
  35. {
  36.     double result = v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
  37.     return result;
  38. }
  39.  
  40. Vector cross(Vector v1, Vector v2)
  41. {
  42.     Vector v;
  43.     v.x = v1.y * v2.z - v1.z * v2.y;
  44.     v.y = v1.z * v2.x - v1.x * v2.z;
  45.     v.z = v1.x * v2.y - v1.y * v2.x;
  46.     return v;
  47. }
  48.  
  49. void setBoundary(Figure *figure)
  50. {
  51.     figure->boundary = malloc(sizeof(int *) * figure->numPoints);
  52.     for (int i = 0; i < figure->numPoints; i++)
  53.     {
  54.         figure->boundary[i] = calloc(figure->numPoints, sizeof(int));
  55.     }
  56.     for (int i = 0; i < figure->numMeshes; i++)
  57.     {
  58.         int a = figure->meshes[i].a;
  59.         int b = figure->meshes[i].b;
  60.         int c = figure->meshes[i].c;
  61.         figure->boundary[a][b]++;
  62.         figure->boundary[b][c]++;
  63.         figure->boundary[c][a]++;
  64.     }
  65. }
  66.  
  67. Figure *makeFigure()
  68. {
  69.     Figure *figure = malloc(sizeof(Figure));
  70.     scanf("%d", &figure->numPoints);
  71.     getchar();
  72.     figure->points = malloc(sizeof(Vector) * figure->numPoints);
  73.     for (int i = 0; i < figure->numPoints; i++)
  74.     {
  75.         scanf("(%lf, %lf, %lf)", &figure->points[i].x, &figure->points[i].y, &figure->points[i].z);
  76.         getchar();
  77.     }
  78.     scanf("%d", &figure->numMeshes);
  79.     getchar();
  80.     figure->meshes = malloc(sizeof(Mesh) * figure->numMeshes);
  81.     for (int i = 0; i < figure->numMeshes; i++)
  82.     {
  83.         scanf("(%d, %d, %d)", &figure->meshes[i].a, &figure->meshes[i].b, &figure->meshes[i].c);
  84.         getchar();
  85.     }
  86.     setBoundary(figure);
  87.     return figure;
  88. }
  89.  
  90. void freeFigure(Figure *figure)
  91. {
  92.     free(figure->points);
  93.     free(figure->meshes);
  94.     for (int i = 0; i < figure->numPoints; i++)
  95.     {
  96.         free(figure->boundary[i]);
  97.     }
  98.     free(figure->boundary);
  99.     free(figure);
  100. }
  101.  
  102. int isOriented(Figure *figure)
  103. {
  104.     for (int i = 0; i < figure->numPoints; i++)
  105.     {
  106.         for (int j = 0; j < figure->numPoints; j++)
  107.         {
  108.             if (figure->boundary[i][j] >= 2)
  109.             {
  110.                 return 0;
  111.             }
  112.         }
  113.     }
  114.     return 1;
  115. }
  116.  
  117. int isClosed(Figure *figure)
  118. {
  119.     if (!isOriented(figure))
  120.     {
  121.         return 0;
  122.     }
  123.     else
  124.     {
  125.         for (int i = 0; i < figure->numPoints; i++)
  126.         {
  127.             for (int j = 0; j < figure->numPoints; j++)
  128.             {
  129.                 if (figure->boundary[i][j] && !figure->boundary[j][i])
  130.                 {
  131.                     return 0;
  132.                 }
  133.             }
  134.         }
  135.         return 1;
  136.     }
  137. }
  138.  
  139. double calculateArea(Figure *figure)
  140. {
  141.     double area = 0.0;
  142.     for (int i = 0; i < figure->numMeshes; i++)
  143.     {
  144.         Vector v1 = subtract(figure->points[figure->meshes[i].b], figure->points[figure->meshes[i].a]);
  145.         Vector v2 = subtract(figure->points[figure->meshes[i].c], figure->points[figure->meshes[i].a]);
  146.         Vector v = cross(v1, v2);
  147.         area += sqrt(dot(v, v)) / 2;
  148.     }
  149.     return area;
  150. }
  151.  
  152. double calculatePerimeter(Figure *figure)
  153. {
  154.     double perimeter = 0.0;
  155.     for (int i = 0; i < figure->numPoints; i++)
  156.     {
  157.         for (int j = 0; j < figure->numPoints; j++)
  158.         {
  159.             if (figure->boundary[i][j] == 1 && figure->boundary[j][i] != 1)
  160.             {
  161.                 Vector v = subtract(figure->points[i], figure->points[j]);
  162.                 perimeter += sqrt(dot(v, v));
  163.             }
  164.         }
  165.     }
  166.     return perimeter;
  167. }
  168.  
  169. double calculateVolume(Figure *figure)
  170. {
  171.     double volume = 0.0;
  172.     for (int i = 0; i < figure->numMeshes; i++)
  173.     {
  174.         Vector v1 = figure->points[figure->meshes[i].a];
  175.         Vector v2 = figure->points[figure->meshes[i].b];
  176.         Vector v3 = figure->points[figure->meshes[i].c];
  177.         volume += dot(v1, cross(v2, v3)) / 6;
  178.     }
  179.     if (volume < 0)
  180.     {
  181.         volume = -volume;
  182.     }
  183.     return volume;
  184. }
  185.  
  186. void printDetails(Figure *figure)
  187. {
  188.     if (isOriented(figure))
  189.     {
  190.         if (isClosed(figure))
  191.         {
  192.             printf("closed and oriented\n");
  193.             printf("volume : %lf\n", calculateVolume(figure));
  194.             printf("area   : %lf\n", calculateArea(figure));
  195.             return;
  196.         }
  197.         else
  198.         {
  199.             printf("oriented\n");
  200.         }
  201.     }
  202.     else
  203.     {
  204.         printf("unoriented\n");
  205.     }
  206.     printf("area     : %lf\n", calculateArea(figure));
  207.     printf("perimeter: %lf\n", calculatePerimeter(figure));
  208. }
  209.  
  210. int main()
  211. {
  212.     Figure *figure = makeFigure();
  213.     printDetails(figure);
  214.     freeFigure(figure);
  215.     return 0;
  216. }
Success #stdin #stdout 0.01s 5316KB
comments (?)
stdin
copy 
4
(0.0, 0.0, 0.0)
(1.0, 0.0, 0.0)
(0.0, 1.0, 0.0)
(0.0, 0.0, 1.0)
4
(0, 2, 1)
(0, 1, 3)
(0, 3, 2)
(1, 2, 3)
stdout
copy 
closed and oriented
volume : 0.166667
area   : 2.366025
https://ideone.com/wn5Bm7
language:
C (gcc 8.3)
created:
2 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!