source: cpp/frams/model/geometry/modelgeometryinfo.cpp @ 224

// This file is a part of the Framsticks GDK.
// Copyright (C) 2002-2014  Maciej Komosinski and Szymon Ulatowski.  See LICENSE.txt for details.
// Refer to http://www.framsticks.com/ for further information.

#include "modelgeometryinfo.h"
#include <frams/model/geometry/geometryutils.h>
#include <frams/model/geometry/meshbuilder.h>

void ModelGeometryInfo::findSizesAndAxesOfModel(const Model &model, const double density,
        Pt3D &sizes, Orient &axes)
{
        SListTempl<Pt3D> points;
        MeshBuilder::ModelApices apices(density);
        apices.initialize(&model);
        apices.addAllPointsToList(points);
        GeometryUtils::findSizesAndAxesOfPointsGroup(points, sizes, axes);
}

bool ModelGeometryInfo::boundingBox(const Model &model, Pt3D &lowerBoundary, Pt3D &upperBoundary)
{
        if (model.getPartCount() == 0)
        {
                return false;
        }
        
        boundingBox(model.getPart(0), lowerBoundary, upperBoundary);
        
        for (int i = 1; i < model.getPartCount(); i++)
        {
                Pt3D partLowerBoundary, partUpperBoundary;
                boundingBox(model.getPart(i), partLowerBoundary, partUpperBoundary);
                
                lowerBoundary.getMin(partLowerBoundary);
                upperBoundary.getMax(partUpperBoundary);
        }
        
        return true;
}

void ModelGeometryInfo::boundingBox(const Part *part, Pt3D &lowerBoundary, Pt3D &upperBoundary)
{
        lowerBoundary.x = upperBoundary.x = part->p.x;
        lowerBoundary.y = upperBoundary.y = part->p.y;
        lowerBoundary.z = upperBoundary.z = part->p.z;
        
        for (Octants::Octant o = Octants::FIRST; o < Octants::NUMBER; o = Octants::Octant(o+1))
        {
                Pt3D vertex = part->scale;
                vertex.x *= Octants::isPositiveX(o) ? +1 : -1;
                vertex.y *= Octants::isPositiveY(o) ? +1 : -1;
                vertex.z *= Octants::isPositiveZ(o) ? +1 : -1;
                
                vertex = part->o.transform(vertex) + part->p;
                
                lowerBoundary.getMin(vertex);
                upperBoundary.getMax(vertex);
        }
}

double ModelGeometryInfo::volume(const Model &model, const double density)
{
        Pt3D lowerBoundary, upperBoundary;
        boundingBox(model, lowerBoundary, upperBoundary);
        
        MeshBuilder::BoundingBoxVolume iterator(density);
        iterator.initialize(lowerBoundary, upperBoundary);
        
        Pt3D point;
        int allPoints = 0, pointsInsideModel = 0;
        
        while (iterator.tryGetNext(point))
        {
                allPoints += 1;
                pointsInsideModel += GeometryUtils::isPointInsideModel(point, model) ? 1 : 0;
        }
        
        double boundingBoxVolume
                = (upperBoundary.x - lowerBoundary.x)
                * (upperBoundary.y - lowerBoundary.y)
                * (upperBoundary.z - lowerBoundary.z);
        
        return boundingBoxVolume * (double)pointsInsideModel / (double)allPoints;
}

double ModelGeometryInfo::area(const Model &model, const double density)
{
        double area = 0.0;
        
        for (int partIndex = 0; partIndex < model.getPartCount(); partIndex+=1)
        {
                area += externalAreaOfPart(model, partIndex, density);
        }
        
        return area;
}

double ModelGeometryInfo::externalAreaOfPart(const Model &model, const int partIndex, const double density)
{
        switch (model.getPart(partIndex)->shape)
        {
                case Part::SHAPE_ELLIPSOID:
                        return externalAreaOfEllipsoid(model, partIndex, density);
                        
                case Part::SHAPE_CUBOID:
                        return externalAreaOfCuboid(model, partIndex, density);
                        
                case Part::SHAPE_CYLINDER:
                        return externalAreaOfCylinder(model, partIndex, density);
        }
}

double externalAreaOfSurface(const Model &model, const int partIndex, MeshBuilder::Iterator &surface, const double area)
{
        Pt3D point;
        int all = 0, sur = 0;
        
        while (surface.tryGetNext(point))
        {
                all += 1;
                sur += GeometryUtils::isPointInsideModelExcludingPart(point, &model, partIndex) ? 0 : 1;
        }
        
        return sur * area / all;
}

double ModelGeometryInfo::externalAreaOfEllipsoid(const Model &model, const int partIndex, const double density)
{
        Part *part = model.getPart(partIndex);
        
        MeshBuilder::EllipsoidSurface ellipsoid(density);
        ellipsoid.initialize(part);
        
        double area = GeometryUtils::ellipsoidArea(part->scale);
        
        return externalAreaOfSurface(model, partIndex, ellipsoid, area);
}

double ModelGeometryInfo::externalAreaOfCuboid(const Model &model, const int partIndex, const double density)
{
        Part *part = model.getPart(partIndex);
        
        double externalArea = 0.0;
        
        MeshBuilder::RectangleSurface rectangle(density);
        
        for (CuboidFaces::Face f = CuboidFaces::FIRST; f < CuboidFaces::NUMBER; f = CuboidFaces::Face(f+1))
        {
                rectangle.initialize(part, f);
                
                double area = 4.0;
                area *= !CuboidFaces::isX(f) ? part->scale.x : 1.0;
                area *= !CuboidFaces::isY(f) ? part->scale.y : 1.0;
                area *= !CuboidFaces::isZ(f) ? part->scale.z : 1.0;
                
                externalArea += externalAreaOfSurface(model, partIndex, rectangle, area);
        }
        
        return externalArea;
}

double ModelGeometryInfo::externalAreaOfCylinder(const Model &model, const int partIndex, const double density)
{
        Part *part = model.getPart(partIndex);
        
        double externalArea = 0.0;
        
        MeshBuilder::EllipseSurface ellipse(density);
        
        double area = M_PI * part->scale.y * part->scale.z;
        
        for (CylinderBases::Base b = CylinderBases::FIRST; b < CylinderBases::NUMBER; b = CylinderBases::Base(b+1))
        {
                ellipse.initialize(part, b);
                
                externalArea += externalAreaOfSurface(model, partIndex, ellipse, area);
        }
        
        MeshBuilder::CylinderWallSurface cylinderWall(density);
        cylinderWall.initialize(part);
        
        area = 2.0*part->scale.x * GeometryUtils::ellipsePerimeter(part->scale.y, part->scale.z);
        
        externalArea += externalAreaOfSurface(model, partIndex, cylinderWall, area);
        
        return externalArea;
}