1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004-2016 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
#include <vcg/space/triangle3.h>
#include <vcg/space/tetra3.h>
#include <vcg/space/sphere3.h>
#include <assert.h>
namespace vcg{
/** \addtogroup space */
/*@{*/
/**
Class for function computing the smallest enclosing bounding volume
*/
struct SmallestEnclosing {
/// computes the smallest enclosing sphere of a triangle
template <class TriangleType>
static Sphere3<typename TriangleType::ScalarType> SphereOfTriangle(const TriangleType & t);
/// computes the smallest enclosing sphere of a tetrahedron
template <class TetraType>
static Sphere3<typename TetraType::ScalarType> SphereOfTetra(const TetraType & t);
/// computes the smallest enclosing sphere of two spheres
template <class SphereType>
static SphereType SphereOfSpheres( const SphereType & s0,const SphereType & s1);
/// computes the smallest enclosing sphere of a container of spheres
template <class SphereContType>
static typename SphereContType::value_type SphereOfSpheres( const SphereContType & t);
};
/*@}*/
template <class TriangleType>
Sphere3<typename TriangleType::ScalarType>
SmallestEnclosing::SphereOfTriangle(const TriangleType & t){
return Sphere3<typename TriangleType::ScalarType>(t.Barycenter(),(t.Barycenter()-t.cP(0)).Norm() );
}
template <class TetraType>
Sphere3<typename TetraType::ScalarType>
SmallestEnclosing::SphereOfTetra(const TetraType & t){
return Sphere3<typename TetraType::ScalarType>( t.Barycenter(),( t.Barycenter() - t.cP(0) ).Norm() );
}
template <class SphereType>
SphereType
SmallestEnclosing::
SphereOfSpheres( const SphereType & s0, const SphereType & s1)
{
typename SphereType::ScalarType radius;
vcg::Point3f center;
if(s0.Radius()==-1.0) return s1; else if(s1.Radius()==-1.0) return s0;
float dst = (s1.Center()-s0.Center()).Norm() ;
radius = (dst+s1.Radius()+s0.Radius())/2;
Point3f a=s0.Center();
Point3f b=s1.Center();
Point3f dir = (b-a).Normalize();
a = a - dir*s0.Radius();
b = b + dir*s1.Radius();
center = (a+b)/2.0;
return SphereType(center,radius);
}
template <typename SphereContType>
typename SphereContType::value_type
SmallestEnclosing::
SphereOfSpheres( const SphereContType & spheres)
{
typename SphereContType::value_type::ScalarType radius;
typename SphereContType::value_type res;
typename SphereContType::const_iterator si;
for(si = spheres.begin(); si != spheres.end(); ++si){
res = SphereOfSpheres(res,*si);
}
return res;
}
}
|
