bool AdaptiveGridTest::init()
{
float gz = 128.f;
setColorScale(.43f / gz);
setNodeDrawSize(gz * .008f);
m_msh.fillBox(BoundingBox(-250.f, -50.f, -250.f,
250.f, 50.f, 250.f), gz);
m_distFunc.addSphere(Vector3F( 9.f, 17.f, -1.f), 27.f );
m_distFunc.addSphere(Vector3F(-54.f, -13.f, -1.f), 64.f );
m_distFunc.addSphere(Vector3F(38.f, -10.f, -22.f), 21.1f );
m_distFunc.addSphere(Vector3F(-100.f, -3420.1f, -100.f), 3400.f );
#define MAX_BUILD_LEVEL 5
#define MAX_BUILD_ERROR .5f
m_msh.adaptiveBuild<BDistanceFunction>(&m_distFunc, MAX_BUILD_LEVEL, MAX_BUILD_ERROR);
std::cout<<"\n triangulating"<<std::endl;
m_msh.triangulateFront();
#if 0
checkTetraVolumeExt<DistanceNode, ITetrahedron>(m_msh.nodes(), m_msh.numTetrahedrons(),
m_msh.tetrahedrons() );
#endif
std::cout.flush();
return true;
}
bool FlyingCamera::onSimCameraQuery(SimCameraQuery *query)
{
SimObjectTransformQuery tquery;
query->cameraInfo.fov = g_rDefaultFOV;
query->cameraInfo.nearPlane = DEFAULT_NEAR_PLANE;
query->cameraInfo.farPlane = getFarPlane();
if (objFollow && objFollow->processQuery(&tquery))
{
Point3F objPos = tquery.tmat.p;
Vector3F x, y, z;
RMat3F rmat(EulerF(rotation.x - M_PI / 2, rotation.y, -rotation.z));
tquery.tmat.p += m_mul(Vector3F(0.0f, rDistance, 0.0f), rmat, &y);
tquery.tmat.p.z += 2.0f;
y.neg();
y.normalize();
m_cross(y, Vector3F(0.0f, 0.0f, 1.0f), &x);
x.normalize();
m_cross(x, y, &z);
tquery.tmat.setRow(0, x);
tquery.tmat.setRow(1, y);
tquery.tmat.setRow(2, z);
// Set our position
findLOSPosition(tquery.tmat, objPos);
}
query->cameraInfo.tmat = getTransform();
return (true);
}
LinearSpline::LinearSpline()
{
addNode();
addNode();
mNodes[0]->position = mNodes[0]->position.value() + Vector3F(-0.5, 0.0, 0.0);
mNodes[1]->position = mNodes[1]->position.value() + Vector3F(+0.5, 0.0, 0.0);
new RenderLinearSpline(getID());
}
float MlRachis::bouncing(const Vector3F & a, const Vector3F & b, const Vector3F & c)
{
float alpha = Vector3F(a, b).normal().dot(Vector3F(a, c).normal());
if(alpha < 0.f) return 0.f;
float lac = Vector3F(a, c).length() * alpha - Vector3F(a, b).length();
float beta = asin(lac / Vector3F(a, c).length());
return 2.f - beta - alpha;
}
/////////////////////////////////////////////////////////////
/// Construit le quaternion à partir de 3 angles d'Euler
///
/// \param X : Angle autour de X
/// \param Y : Angle autour de Y
/// \param Z : Angle autour de Z
///
////////////////////////////////////////////////////////////
void Quaternion::FromEulerAngles(float X, float Y, float Z)
{
Quaternion Qx(Vector3F(1, 0, 0), X);
Quaternion Qy(Vector3F(0, 1, 0), Y);
Quaternion Qz(Vector3F(0, 0, 1), Z);
*this = Qx * Qy * Qz;
}
void BaseView::frameAll()
{
m_centerOfInterest.setZero();
m_space.setIdentity();
m_space.setTranslation(Vector3F(0.f, 0.f, 100.f) );
m_invSpace.setIdentity();
m_invSpace.setTranslation(Vector3F(0.f, 0.f, -100.f) );
}
float MlRachis::distanceFactor(const Vector3F & a, const Vector3F & b, const Vector3F & c)
{
float facing = Vector3F(a, b).normal().dot(Vector3F(a, c).normal());
float lac = Vector3F(a, c).length() * facing;
float lab = Vector3F(a, b).length();
if(lac > lab) return 0.f;
float ang = 1.f - lac / lab * (lac / lab);
return ang * 3;
}
Vector3F Vector3F::Normalize()
{
double mag = sqrt(x*x + y*y + z*z);
if (mag == 0) return Vector3F(0, 0, 0);
//Assert(mag != 0, "Vector3F::Normalize vector of magnitude 0 was requested to be normalized.");
mag = 1.0/mag;
return Vector3F(x*mag, y*mag, z*mag);
}
BaseView::BaseView()
{
m_centerOfInterest.set(0.f, 0.f, 0.f);
m_space.setIdentity();
m_space.setTranslation(Vector3F(0.f, 0.f, 100.f) );
m_invSpace.setIdentity();
m_invSpace.setTranslation(Vector3F(0.f, 0.f, -100.f) );
/// 35mm Academy
std::cout<<"\n angle of view "<<180.f/3.14f*2.f * atan(21.9456f/2.f/35.f)<<" deg";
setFrustum(.864f, .63f, 35.f, -1.f, -20000.f);
}
const Vector3F BoundingBox::corner(const int & i) const
{
const int iz = i / 4;
const int iy = (i - iz * 4) / 2;
const int ix = i - iy * 2 - iz * 4;
return Vector3F(m_data[3 * ix], m_data[1 + 3 * iy], m_data[2 + 3 * iz]);
}
Vector3F operator*(Matrix4x4F & A, Vector3F & v)
{
return Vector3F(
A.m[0][0]*v.x + A.m[0][1]*v.y + A.m[0][2]*v.z + A.m[0][3],
A.m[1][0]*v.x + A.m[1][1]*v.y + A.m[1][2]*v.z + A.m[1][3],
A.m[2][0]*v.x + A.m[2][1]*v.y + A.m[2][2]*v.z + A.m[2][3]);
}
void QuatJulia::generate()
{
/// eval at uniform grid
int i, j, k;
const float grid = 1.f / (float)m_numGrid;
const Vector3F origin(-.5f+grid * .5f,
-.5f+grid * .5f,
-.5f+grid * .5f);
int n = 0;
for(k=0; k<m_numGrid; ++k ) {
for(j=0; j<m_numGrid; ++j ) {
for(i=0; i<m_numGrid; ++i ) {
Vector3F sample = origin + Vector3F(grid * i, grid * j, grid * k);
if( evalAt( sample*3.2f ) > 0.f ) {
n++;
cvx::Sphere sp;
sample *= m_scaling;
sp.set(sample, .001f);
m_tree->insert((const float *)&sample, sp);
}
}
}
}
m_tree->finishInsert();
}
void UniformGrid::refine(KdTree * tree)
{
int level1;
float hh;
Vector3F sample, subs;
int u;
unsigned k;
BoundingBox box;
m_cellsToRefine->begin();
while (!m_cellsToRefine->end()) {
sdb::CellValue * parentCell = m_cellsToRefine->value();
if(parentCell->visited > 0) {
k = m_cellsToRefine->key();
level1 = parentCell->level + 1;
hh = cellSizeAtLevel(level1) * .5f;
sample = cellCenter(k);
removeCell(k);
for(u = 0; u < 8; u++) {
subs = sample + Vector3F(hh * Cell8ChildOffset[u][0],
hh * Cell8ChildOffset[u][1],
hh * Cell8ChildOffset[u][2]);
box.setMin(subs.x - hh, subs.y - hh, subs.z - hh);
box.setMax(subs.x + hh, subs.y + hh, subs.z + hh);
if(tree->intersectBox(box))
addCell(subs, level1);
}
}
m_cellsToRefine->next();
}
}
void BccLattice::add24Tetrahedron(const Vector3F & center, float h)
{
const unsigned ccenter = mortonEncode(center);
unsigned cgreen;
Vector3F corner;
unsigned vOctahedron[6];
int i;
for(i=0; i < 6; i++) {
corner = center + Vector3F(h * HexHeighborOffset[i][0],
h * HexHeighborOffset[i][1],
h * HexHeighborOffset[i][2]);
cgreen = mortonEncode(corner);
sdb::EdgeValue * edge = m_greenEdges->findEdge(ccenter, cgreen);
if(!edge) {
// std::cout<<" edge "<<i<<" connected to "<<center<<" doesn't exist!\n";
continue;
}
if(edge->visited == 0) {
encodeOctahedronVertices(center, h, i, vOctahedron);
addTetrahedronsAllNodeVisited(vOctahedron);
edge->visited = 1;
}
}
}
Vector3F operator*(Vector3F & v, Matrix4x4F & A)
{
return Vector3F(
v.x*A.m[0][0] + v.y*A.m[1][0] + v.z*A.m[2][0] + A.m[3][0],
v.x*A.m[0][1] + v.y*A.m[1][1] + v.z*A.m[2][1] + A.m[3][1],
v.x*A.m[0][2] + v.y*A.m[1][2] + v.z*A.m[2][2] + A.m[3][2]);
}
IFloatBuffer* NormalsUtils::createTriangleSmoothNormals(const IFloatBuffer* vertices,
const IShortBuffer* indices) {
const int verticesSize = vertices->size();
IFloatBuffer* normals = IFactory::instance()->createFloatBuffer(verticesSize);
for (int i = 0; i < verticesSize; i++) {
normals->rawPut(i, 0);
}
const int indicesSize = indices->size();
for (int i = 0; i < indicesSize; i += 3) {
const short index0 = indices->get(i);
const short index1 = indices->get(i + 1);
const short index2 = indices->get(i + 2);
const Vector3F normal = calculateNormal(vertices, index0, index1, index2);
addNormal(normals, index0, normal);
addNormal(normals, index1, normal);
addNormal(normals, index2, normal);
}
for (int i = 0; i < verticesSize; i += 3) {
const float x = normals->get(i);
const float y = normals->get(i + 1);
const float z = normals->get(i + 2);
const Vector3F normal = Vector3F(x, y, z).normalized();
normals->rawPut(i , normal._x);
normals->rawPut(i + 1, normal._y);
normals->rawPut(i + 2, normal._z);
}
return normals;
}
Vector3F operator^(Matrix4x4F & A, Vector3F & v)
{
return Vector3F(
A.m[0][0]*v.x + A.m[0][1]*v.y + A.m[0][2]*v.z,
A.m[1][0]*v.x + A.m[1][1]*v.y + A.m[1][2]*v.z,
A.m[2][0]*v.x + A.m[2][1]*v.y + A.m[2][2]*v.z);
}
void Base3DView::frameAll()
{
Vector3F coi = sceneCenter();
Vector3F eye = coi + Vector3F(0.f, 0.f, 100.f);
getCamera()->lookFromTo(eye, coi);
}
void BccWorld::createTestCurveGeometry()
{
std::cout<<" gen 1 test curve";
m_curves->create(1, 9);
m_curves->counts()[0] = 9;
Vector3F * cvs = m_curves->points();
cvs[0].set(8.f + RandomFn11(), 1.f + RandomFn11(), 4.1f);
cvs[1].set(2.f + RandomFn11(), 9.4f + RandomFn11(), 1.11f);
cvs[2].set(14.f + RandomFn11(), 8.4f + RandomFn11(), -3.13f);
cvs[3].set(12.f + RandomFn11(), 1.4f + RandomFn11(), 1.14f);
cvs[4].set(19.f + RandomFn11(), 2.4f + RandomFn11(), 2.16f);
cvs[5].set(20.f + RandomFn11(), 3.4f + RandomFn11(), 5.17f);
cvs[6].set(18.f + RandomFn11(), 12.2f + RandomFn11(), 3.18f);
cvs[7].set(12.f + RandomFn11(), 12.2f + RandomFn11(), 2.19f);
cvs[8].set(13.f + RandomFn11(), 8.2f + RandomFn11(), -2.18f);
for(unsigned i=0; i<9;i++) {
cvs[i] -= Vector3F(12.f, 0.f, 0.f);
cvs[i] *= 3.f;
}
m_allGeo = new GeometryArray;
m_allGeo->create(1);
CurveBuilder cb;
unsigned i;
for(i=0; i< 9; i++)
cb.addVertex(cvs[i]);
BezierCurve * c = new BezierCurve;
cb.finishBuild(c);
m_allGeo->setGeometry(c, 0);
}
Vector3F Matrix44F::transform(const Vector3F& p) const
{
float tx = p.x * M(0, 0) + p.y * M(1, 0) + p.z * M(2, 0) + M(3, 0);
float ty = p.x* M(0, 1) + p.y* M(1, 1) + p.z* M(2, 1) + M(3, 1);
float tz = p.x* M(0, 2) + p.y* M(1, 2) + p.z* M(2, 2) + M(3, 2);
return Vector3F(tx, ty, tz);
}
Vector3F Matrix44F::transformAsNormal(const Vector3F& p)
{
float tx = p.x* *m(0, 0) + p.y* *m(1, 0) + p.z* *m(2, 0);
float ty = p.x* *m(0, 1) + p.y* *m(1, 1) + p.z* *m(2, 1);
float tz = p.x* *m(0, 2) + p.y* *m(1, 2) + p.z* *m(2, 2);
return Vector3F(tx, ty, tz);
}
AABB AABB::CreateAABBfromCone(const Cone& c)
{
// Construct AABB for cone base
Vector3F baseX = Vector3F(1.f - c.mDir.x * c.mDir.x, c.mDir.x * c.mDir.y, c.mDir.x * c.mDir.z).GetNormalized() * c.mBaseRadius;
Vector3F baseY = Vector3F(c.mDir.y * c.mDir.x, 1.f - c.mDir.y * c.mDir.y, c.mDir.y * c.mDir.z).GetNormalized() * c.mBaseRadius;
Vector3F baseZ = Vector3F(c.mDir.z * c.mDir.x, c.mDir.z * c.mDir.y, 1.f - c.mDir.z * c.mDir.z).GetNormalized() * c.mBaseRadius;
Vector3F aabbMax = Vector3F(baseX.x, baseY.y, baseZ.z).Abs();
Vector3F aabbMin = -aabbMax;
AABB result(aabbMin, aabbMax);
result.Move(c.mBase);
// add tip
result.Add(c.mTip);
return result;
}
Vector3F Vector3F::NormalizeSq()
{
double mag = x*x + y*y + z*z;
Assert(mag != 0, "Vector3F::Normalize vector of magnitude 0 was requested to be normalized.");
mag = 1.0/mag;
return Vector3F(x*x*mag, y*y*mag, z*z*mag);
}
void FEMTetrahedronMesh::generateBlocks(unsigned xdim, unsigned ydim, unsigned zdim, float width, float height, float depth)
{
m_totalPoints = (xdim+1)*(ydim+1)*(zdim+1);
m_X = new Vector3F[m_totalPoints];
m_Xi= new Vector3F[m_totalPoints];
m_mass = new float[m_totalPoints];
int ind=0;
float hzdim = zdim/2.0f;
for(unsigned x = 0; x <= xdim; ++x) {
for (unsigned y = 0; y <= ydim; ++y) {
for (unsigned z = 0; z <= zdim; ++z) {
m_X[ind] = Vector3F(width*x, height*z, depth*y);
m_Xi[ind] = m_X[ind];
ind++;
}
}
}
//offset the m_tetrahedronl mesh by 0.5 units on y axis
//and 0.5 of the depth in z axis
for(unsigned i=0;i< m_totalPoints;i++) {
m_X[i].y += 2.5;
m_X[i].z -= hzdim*depth;
}
m_totalTetrahedrons = 5 * xdim * ydim * zdim;
m_tetrahedron = new Tetrahedron[m_totalTetrahedrons];
Tetrahedron * t = &m_tetrahedron[0];
for (unsigned i = 0; i < xdim; ++i) {
for (unsigned j = 0; j < ydim; ++j) {
for (unsigned k = 0; k < zdim; ++k) {
unsigned p0 = (i * (ydim + 1) + j) * (zdim + 1) + k;
unsigned p1 = p0 + 1;
unsigned p3 = ((i + 1) * (ydim + 1) + j) * (zdim + 1) + k;
unsigned p2 = p3 + 1;
unsigned p7 = ((i + 1) * (ydim + 1) + (j + 1)) * (zdim + 1) + k;
unsigned p6 = p7 + 1;
unsigned p4 = (i * (ydim + 1) + (j + 1)) * (zdim + 1) + k;
unsigned p5 = p4 + 1;
// Ensure that neighboring tetras are sharing faces
if ((i + j + k) % 2 == 1) {
addTetrahedron(t++, p1,p2,p6,p3);
addTetrahedron(t++, p3,p6,p4,p7);
addTetrahedron(t++, p1,p4,p6,p5);
addTetrahedron(t++, p1,p3,p4,p0);
addTetrahedron(t++, p1,p6,p4,p3);
} else {
addTetrahedron(t++, p2,p0,p5,p1);
addTetrahedron(t++, p2,p7,p0,p3);
addTetrahedron(t++, p2,p5,p7,p6);
addTetrahedron(t++, p0,p7,p5,p4);
addTetrahedron(t++, p2,p0,p7,p5);
}
}
}
}
}
WireAttribute::Ptr WireAttribute::create(const std::string& name,
WireAttribute::AttributeType type) {
if (name == "vertex_min_angle") {
return Ptr(new WireVertexMinAngleAttribute);
} else if (name == "vertex_periodic_index") {
return Ptr(new WireVertexPeriodicIndexAttribute);
} else if (name == "vertex_symmetry_orbit") {
return Ptr(new WireVertexSymmetryAttribute);
} else if (name == "vertex_cubic_symmetry_orbit") {
return Ptr(new WireVertexCubicSymmetryAttribute);
} else if (name == "vertex_support_X") {
Vector3F print_dir = Vector3F::UnitX();
return Ptr(new WireVertexSupportAttribute(print_dir));
} else if (name == "vertex_support_Y") {
Vector3F print_dir = Vector3F::UnitY();
return Ptr(new WireVertexSupportAttribute(print_dir));
} else if (name == "vertex_support_Z") {
Vector3F print_dir = Vector3F::UnitZ();
return Ptr(new WireVertexSupportAttribute(print_dir));
} else if (name == "vertex_support_XY") {
Vector3F print_dir = Vector3F(1.0, 1.0, 0.0).normalized();
return Ptr(new WireVertexSupportAttribute(print_dir));
} else if (name == "vertex_support_YZ") {
Vector3F print_dir = Vector3F(0.0, 1.0, 1.0).normalized();
return Ptr(new WireVertexSupportAttribute(print_dir));
} else if (name == "vertex_support_ZX") {
Vector3F print_dir = Vector3F(1.0, 0.0, 1.0).normalized();
return Ptr(new WireVertexSupportAttribute(print_dir));
} else if (name == "vertex_support_XYZ") {
Vector3F print_dir = Vector3F(1.0, 1.0, 1.0).normalized();
return Ptr(new WireVertexSupportAttribute(print_dir));
} else if (name == "edge_length") {
return Ptr(new WireEdgeLengthAttribute);
} else if (name == "edge_periodic_index") {
return Ptr(new WireEdgePeriodicIndexAttribute);
} else if (name == "edge_symmetry_orbit") {
return Ptr(new WireEdgeSymmetryAttribute);
} else if (name == "edge_cubic_symmetry_orbit") {
return Ptr(new WireEdgeCubicSymmetryAttribute);
} else {
Ptr attr = Ptr(new WireAttribute);
attr->set_attribute_type(type);
return attr;
}
}
//! [0]
GLWidget::GLWidget(QWidget *parent) : Base3DView(parent)
{
QTimer *timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(simulate()));
timer->start(30);
m_drawer = new KdTreeDrawer;
rbf = new RadialBasisFunction;
rbf->create(7);
rbf->setXi(0, Vector3F(0,0,0));
rbf->setXi(1, Vector3F(8,0,0));
rbf->setXi(2, Vector3F(2.5,8.5,0));
rbf->setXi(3, Vector3F(-8,0.2,1.0));
rbf->setXi(4, Vector3F(-0.2,-8.2,-0.1));
rbf->setXi(5, Vector3F(-0.1,-1.2, 7.1));
rbf->setXi(6, Vector3F(9.0, 5.2, 2.1));
rbf->setTau(16.0);
rbf->computeWeights();
m_anchor = new Anchor;
Vector3F pa(-7.0, 5., 0.);
m_anchor->placeAt(pa);
rbf->solve(m_anchor->getCenter());
}
Vector3F Vector3F::perpendicular() const
{
Vector3F ref(0,1,0);
Vector3F n = normal();
if(n.y < -0.9f || n.y > 0.9f) ref = Vector3F(1,0,0);
Vector3F per = cross(ref);
per.normalize();
return per;
}
RandomMesh::RandomMesh(unsigned numFaces, const Vector3F & center, const float & size, int type)
{
createBuffer(numFaces * 4, numFaces * 4);
Vector3F * p = points();
unsigned * idx = indices();
float rx, ry, rz, r, phi, theta;
for(unsigned i = 0; i < numFaces; i++) {
idx[i * 3] = i * 3;
idx[i * 3 + 1] = i * 3 + 1;
idx[i * 3 + 2] = i * 3 + 2;
if(type == 0) {
rx = (float(rand()%694) / 694.f - 0.5f) * 1.4f;
ry = (float(rand()%594) / 594.f - 0.5f) * 1.4f;
rz = (float(rand()%794) / 794.f - 0.5f) * 1.4f;
}
else {
phi = ((float)(rand() % 25391)) / 25391.f * 2.f * 3.14f;
theta = ((float)(rand() % 24331)) / 24331.f * 3.14f;
r = ((float)(rand() % 24091)) / 24091.f * .1f + 0.9f;
rx = sin(theta) * cos(phi);
ry = sin(theta) * sin(phi);
rz = cos(theta);
}
p[i * 3] = center + Vector3F(rx * size, ry * size, rz * size);
rx = float(rand()%294) / 294.f - 0.5f;
ry = float(rand()%594) / 594.f - 0.5f;
rz = float(rand()%794) / 794.f - 0.5f;
p[i * 3 + 1] = p[i * 3] + Vector3F(rx, ry, rz);
rx = float(rand()%394) / 394.f - 0.5f;
ry = float(rand()%594) / 594.f - 0.5f;
rz = float(rand()%794) / 794.f - 0.5f;
p[i * 3 + 2] = p[i * 3] + Vector3F(rx, ry, rz);
}
setNumPoints(numFaces * 3);
setNumIndices(numFaces * 3);
}
void BccLattice::addNeighborTetrahedron(const Vector3F & center, float h)
{
Vector3F corner;
int i;
for(i=0; i < 6; i++) {
corner = center + Vector3F(h * HexHeighborOffset[i][0],
h * HexHeighborOffset[i][1],
h * HexHeighborOffset[i][2]);
add24Tetrahedron(corner, h);
}
}
void extract_mesh(const C3t3& c3t3,
MatrixFr& vertices, MatrixIr& faces, MatrixIr& voxels) {
const Tr& tr = c3t3.triangulation();
size_t num_vertices = tr.number_of_vertices();
size_t num_faces = c3t3.number_of_facets_in_complex();
size_t num_voxels = c3t3.number_of_cells_in_complex();
vertices.resize(num_vertices, 3);
faces.resize(num_faces, 3);
voxels.resize(num_voxels, 4);
std::map<Tr::Vertex_handle, int> V;
size_t inum = 0;
for(auto vit = tr.finite_vertices_begin();
vit != tr.finite_vertices_end(); ++vit) {
V[vit] = inum;
const auto& p = vit->point();
vertices.row(inum) = Vector3F(p.x(), p.y(), p.z()).transpose();
assert(inum < num_vertices);
inum++;
}
assert(inum == num_vertices);
size_t face_count = 0;
for(auto fit = c3t3.facets_in_complex_begin();
fit != c3t3.facets_in_complex_end(); ++fit) {
assert(face_count < num_faces);
for (int i=0; i<3; i++) {
if (i != fit->second) {
const auto& vh = (*fit).first->vertex(i);
assert(V.find(vh) != V.end());
const int vid = V[vh];
faces(face_count, i) = vid;
}
}
face_count++;
}
assert(face_count == num_faces);
size_t voxel_count = 0;
for(auto cit = c3t3.cells_in_complex_begin() ;
cit != c3t3.cells_in_complex_end(); ++cit ) {
assert(voxel_count < num_voxels);
for (int i=0; i<4; i++) {
assert(V.find(cit->vertex(i)) != V.end());
const size_t vid = V[cit->vertex(i)];
voxels(voxel_count, i) = vid;
}
voxel_count++;
}
assert(voxel_count == num_voxels);
}
