Использование комментариев

#
pragma once
#include "Vector3D.h"
 
namespace Tetrahedron
{
 
    class Tetrader
    {
    protected:
        double surfaceArea;             // площадь
        double facets;                  // грани
        double edgeLength;              // длина ребра
        double volume;                  // объём
        double height;                  // высота
        double baseArea;                // площадь основания
        double diagonal;                // диагональ
        double sideFaceHeight;          // высота боковой грани
        double radiusoInscribedSphere;  // радиус вписанной сферы
        double radiusDescribedSphere;   // радиус описанной сферы
 
    public:
 
        // Constructors
        Tetrader();
 
 
        // Methods 
        // Вычисление объема тетраэдра на основе координат вершин
        double calculateVolume(const Vector3D& vertexA, const Vector3D& vertexB, const Vector3D& vertexC, const Vector3D& vertexD);
 
        // Вычисление длины ребра тетраэдра
        double calculateEdgeLength(const Vector3D& vertexA, const Vector3D& vertexB);
 
        // Вычисление площади грани тетраэдра на основе координат трех вершин
        double calculateFaceArea(const Vector3D& vertexA, const Vector3D& vertexB, const Vector3D& vertexC);
 
        // Вычисление радиуса вписанной сферы в тетраэдр
        double calculateInscribedSphereRadius(double volume, double faceArea);
 
        // Вычисление радиуса описанной сферы вокруг тетраэдра
        double calculateCircumscribedSphereRadius(double edgeLengthA, double edgeLengthB, double edgeLengthC, double volume);
 
        // Нормализация вектора
        void normalizeVector(Vector3D& vector);
 
    };
 
    class RegularTetrader : public Tetrader
    {
    public:
        // Constructors;
        RegularTetrader();
        RegularTetrader(double edgeLength);
 
        // Methods
        // Вычисление объема равногранного тетраэдра
        double calculateVolume();
 
        // Вычисление площади поверхности равногранного тетраэдра
        double calculateSurfaceArea();
 
        // Вычисление радиуса вписанной сферы равногранного тетраэдра
        double findingInscribedSphereRadius();
 
        // Вычисление радиуса описанной сферы равногранного тетраэдра
        double findCircumscribedSphereRadius();
 
        // Вычисление высоты  равногранного тетраэдра
        double calculateHeight();
 
        // Вычисление длины диагонали равногранного тетраэдра 
        double diagonalLength();
 
        // Вычисление площадь основания равногранного тетраэдра
        double calculateBaseArea();
 
        // Вычисление высоты боковой грани равногранного тетраэдра
        double calculateSideFaceHeight();
    };
};

#include "Tetrader.h"
#include "Vector3D.h"
#include <cmath>
 
using namespace Tetrahedron;
 
// Tetrader Implementation
// Default Comstructor
Tetrader::Tetrader() : surfaceArea(0), facets(0), edgeLength(0), volume(0), height(0), radiusoInscribedSphere(0), radiusDescribedSphere(0) {};
 
 
// Methods
// Вычисление объема тетраэдра на основе координат вершин
double Tetrader::calculateVolume(const Vector3D& vertexA, const Vector3D& vertexB, const Vector3D& vertexC, const Vector3D& vertexD)
{
    Vector3D ab = vertexB - vertexA;
    Vector3D ac = vertexC - vertexA;
    Vector3D ad = vertexD - vertexA;
 
    double volume = (1.0 / 6.0) * std::abs(ab.dot(ac.cross(ad)));
    return volume;
}
 
// Вычисление длины ребра тетраэдра
double Tetrader::calculateEdgeLength(const Vector3D& vertexA, const Vector3D& vertexB)
{
    Vector3D ab = vertexB - vertexA;
 
    double edgeLength = std::abs(ab.dot(ab));
    return std::sqrt(edgeLength);
}
 
// Вычисление площади грани тетраэдра на основе координат трех вершин
double Tetrader::calculateFaceArea(const Vector3D& vertexA, const Vector3D& vertexB, const Vector3D& vertexC)
{
    Vector3D ab = vertexB - vertexA;
    Vector3D ac = vertexC - vertexA;
 
    double faceArea = 0.5 * std::abs(ab.cross(ac).dot(ab.cross(ac)));
    return faceArea;
}
 
// Вычисление радиуса вписанной сферы в тетраэдр
double Tetrader::calculateInscribedSphereRadius(double volume, double faceArea)
{
    double radius = (3.0 * volume) / faceArea;
    return radius;
}
 
// Вычисление радиуса описанной сферы вокруг тетраэдра
double Tetrader::calculateCircumscribedSphereRadius(double edgeLengthA, double edgeLengthB, double edgeLengthC, double volume)
{
    double radius = (edgeLengthA * edgeLengthB * edgeLengthC) / (4.0 * volume);
    return radius;
}
 
// Нормализация вектора
void Tetrader::normalizeVector(Vector3D& vector)
{
    vector.normalize();
}
 
 
 
 
// RegularTetrader Implementation
RegularTetrader::RegularTetrader() :Tetrader() {};
 
RegularTetrader::RegularTetrader(double edgeLength)
{
    this->edgeLength = edgeLength;
}
 
 
// Methods
// Вычисление объема равногранного тетраэдра
double RegularTetrader::calculateVolume()
{
    volume = (pow(edgeLength, 3) * sqrt(2)) / 12;
    return volume;
};
 
// Вычисление площади поверхности равногранного тетраэдра
double RegularTetrader::calculateSurfaceArea()
{
    surfaceArea = sqrt(3) * pow(edgeLength, 2);
    return surfaceArea;
}
 
// Вычисление радиуса вписанной сферы равногранного тетраэдра
double RegularTetrader::findingInscribedSphereRadius()
{
    radiusoInscribedSphere = (edgeLength * sqrt(6)) / 12;
    return radiusoInscribedSphere;
}
 
// Вычисление радиуса описанной сферы равногранного тетраэдра
double RegularTetrader::findCircumscribedSphereRadius()
{
    radiusDescribedSphere = (edgeLength * sqrt(6)) / 4;
    return radiusDescribedSphere;
}
 
// Вычисление высоты  равногранного тетраэдра
double RegularTetrader::calculateHeight()
{
    height = (edgeLength * sqrt(6)) / 3;
    return height;
}
 
// Вычисление длины диагонали равногранного тетраэдра 
double RegularTetrader::diagonalLength()
{
    diagonal = edgeLength * sqrt(2);
    return diagonal;
}
 
// Вычисление площадь основания равногранного тетраэдра
double RegularTetrader::calculateBaseArea()
{
    baseArea = (sqrt(3) * pow(edgeLength, 2)) / 4;
    return baseArea;
}
 
// Вычисление высоты боковой грани равногранного тетраэдра
double RegularTetrader::calculateSideFaceHeight()
{
    sideFaceHeight = (edgeLength * sqrt(6)) / 4;
    return sideFaceHeight;
}

#include <iostream>
#include <vector>
#include "function-tetrader.h"
#include "Vector3D.h"
 
// Главные функци
 
void processingTetrahedronOperations()
{
    bool exit = false;
 
    while (!exit)
    {
        // Вызов функции для выбора типа тетраэдра
        choosingShapeType();
 
        int choice;
        std::cin >> choice;
 
        // Объекты необходимые для выполнения операций 
        std::vector<Vector3D> vector;
        Tetrader tetrader;
        
 
        switch (choice)
        {
        case 1:
        {
            std::cout << "Что желаете найти?." << std::endl;
            std::cout << "1. Вычисление длины ребра тетраэдра." << std::endl;
            std::cout << "2. Вычисление объема тетраэдра на основе координат вершин." << std::endl;
            std::cout << "3. Вычисление площади грани тетраэдра на основе координат трех вершин." << std::endl;
            std::cout << "4. Вычисление радиуса вписанной сферы в тетраэдр." << std::endl;
            std::cout << "5. Вычисление радиуса описанной сферы вокруг тетраэдра." << std::endl;
 
            std::cout << "Ввод: ";
            std::cin >> choice;
 
            int count = 0;
 
            switch (choice)
            {
            case 0:
            {
                exit = true;
                system("pause");
                system("cls");
                
            }
            case 1:
            {
                count = 2;
 
                initializingVertexes(vector, count);
                double edgeLength = tetrader.calculateEdgeLength(vector[0], vector[1]);
 
                std::cout << "Результат: " << edgeLength << std::endl;
                break;
            }
            case 2:
            {
                count = 4;
 
                initializingVertexes(vector, count);
                double volume = tetrader.calculateVolume(vector[0], vector[1], vector[2], vector[3]);
 
                std::cout << "Результат: " << volume << std::endl;
                break;
            }
            case 3:
            {
                count = 3;
 
                initializingVertexes(vector, count);
                double faceArea = tetrader.calculateFaceArea(vector[0], vector[1], vector[2]);
 
                std::cout << "Результат: " << std::endl;
                break;
            }
            case 4:
            {
                std::cout << "Укажите объём: ";
            }
            default:
            {
                std::cout << "Ошибка выбора, попробуйте снова!";
                system("pause");
                system("cls");
                break;
            }
            }
            
            break;
        }
        default:
            break;
        }
    }
}
 
 
 
 
// Второстепенные функции 
// Выбор типа тетраэдра
void choosingShapeType()
{
    std::cout << "1. Использовать координаты вершины для выполнения операций с любым тетраэдром." << std::endl;
    std::cout << "2. Использовать правильный тетраэдр для выполнения операций." << std::endl;
    std::cout << "3. Использовать прямоугольный тетраэдр для выполнения операций." << std::endl;
    std::cout << "4. Использовать ортоцентричный тетраэдр для выполнения операций." << std::endl;
    std::cout << "5. Выйти в главное меню." << std::endl;
    std::cout << "Ввод: ";
}
 
// Инициализация вершин тетраэдра
void initializingVertexes(std::vector<Vector3D>& vector, int count) 
{
    for (int i = 0; i < count; i++)
    {
        double x;
        double y;
        double z;
 
        std::cout << "Координаты " << i + 1 << "-ой вершины:" << std::endl;
 
        std::cout << "x: ";
        std::cin >> x;
        std::cout << "y: ";
        std::cin >> y;
        std::cout << "z: ";
        std::cin >> z;
 
        Vector3D vertexes(x, y, z);
        vector.push_back(vertexes);
    }
}

avformat_alloc_output_context2(&encode_ctx, NULL, ext, video_dst_filename);
  
  AVOutputFormat *fmt = encode_ctx->oformat;
   /* Добавьте аудио- и видеопотоки, используя кодеки формата по умолчанию
  * и инициализировать кодеки. */
  bool video_codec_id = false;
  if (video_stream){
      if (fmt->video_codec != AV_CODEC_ID_NONE) {//  Посылает fmt->video_codec исходя из расширения (функция  выше)
          add_stream(video_st, fmt->video_codec, kf_bitrate, audio_bt);
  // ------------------------------- Вызов двух функций инициализации VIDEO
                      } 
 // printf("Input video codec_id: %s \n", avcodec_get_name(video_st->dec_ctx->codec_id));
     if (video_st->dec_ctx->codec_id == 71)video_codec_id = true;// Ахуенно сложная хуйня. Для wmv, кое что переключаеться
  }