MeshPointGrid::MeshPointGrid (const MeshKernel &rclM, float fGridLen)
: MeshGrid(rclM)
{
Base::BoundBox3f clBBMesh = _pclMesh->GetBoundBox();
Rebuild(std::max<unsigned long>((unsigned long)(clBBMesh.LengthX() / fGridLen), 1),
std::max<unsigned long>((unsigned long)(clBBMesh.LengthY() / fGridLen), 1),
std::max<unsigned long>((unsigned long)(clBBMesh.LengthZ() / fGridLen), 1));
}
MeshEigensystem::MeshEigensystem (const MeshKernel &rclB)
: MeshEvaluation(rclB), _cU(1.0f, 0.0f, 0.0f), _cV(0.0f, 1.0f, 0.0f), _cW(0.0f, 0.0f, 1.0f)
{
// use the values of world coordinates as default
Base::BoundBox3f box = _rclMesh.GetBoundBox();
_fU = box.LengthX();
_fV = box.LengthY();
_fW = box.LengthZ();
}
Base::BoundBox3d MeshObject::getBoundBox(void)const
{
const_cast<MeshCore::MeshKernel&>(_kernel).RecalcBoundBox();
Base::BoundBox3f Bnd = _kernel.GetBoundBox();
Base::BoundBox3d Bnd2;
for(int i =0 ;i<=7;i++)
Bnd2.Add(transformToOutside(Bnd.CalcPoint(i)));
return Bnd2;
}
void MeshGrid::InitGrid (void)
{
assert(_pclMesh != NULL);
unsigned long i, j;
// Grid Laengen berechnen wenn nicht initialisiert
//
if ((_ulCtGridsX == 0) || (_ulCtGridsX == 0) || (_ulCtGridsX == 0))
CalculateGridLength(MESH_CT_GRID, MESH_MAX_GRIDS);
// Grid Laengen und Offset bestimmen
//
{
Base::BoundBox3f clBBMesh = _pclMesh->GetBoundBox();
float fLengthX = clBBMesh.LengthX();
float fLengthY = clBBMesh.LengthY();
float fLengthZ = clBBMesh.LengthZ();
{
// Offset fGridLen/2
//
_fGridLenX = (1.0f + fLengthX) / float(_ulCtGridsX);
_fMinX = clBBMesh.MinX - 0.5f;
}
{
_fGridLenY = (1.0f + fLengthY) / float(_ulCtGridsY);
_fMinY = clBBMesh.MinY - 0.5f;
}
{
_fGridLenZ = (1.0f + fLengthZ) / float(_ulCtGridsZ);
_fMinZ = clBBMesh.MinZ - 0.5f;
}
}
// Daten-Struktur anlegen
_aulGrid.clear();
_aulGrid.resize(_ulCtGridsX);
for (i = 0; i < _ulCtGridsX; i++)
{
_aulGrid[i].resize(_ulCtGridsY);
for (j = 0; j < _ulCtGridsY; j++)
_aulGrid[i][j].resize(_ulCtGridsZ);
}
}
void PlaneFit::Dimension(float& length, float& width) const
{
const Base::Vector3f& bs = _vBase;
const Base::Vector3f& ex = _vDirU;
const Base::Vector3f& ey = _vDirV;
Base::BoundBox3f bbox;
std::list<Base::Vector3f>::const_iterator cIt;
for (cIt = _vPoints.begin(); cIt != _vPoints.end(); ++cIt) {
Base::Vector3f pnt = *cIt;
pnt.TransformToCoordinateSystem(bs, ex, ey);
bbox.Add(pnt);
}
length = bbox.MaxX - bbox.MinX;
width = bbox.MaxY - bbox.MinY;
}
bool MeshProjection::bboxInsideRectangle(const Base::BoundBox3f& bbox,
const Base::Vector3f& p1,
const Base::Vector3f& p2,
const Base::Vector3f& view) const
{
Base::Vector3f dir(p2 - p1);
Base::Vector3f base(p1), normal(view % dir);
normal.Normalize();
if (bbox.IsCutPlane(base, normal)) {
dir.Normalize();
Base::Vector3f cnt(bbox.GetCenter());
return (fabs(cnt.DistanceToPlane(p1, dir)) + fabs(cnt.DistanceToPlane(p2, dir))) <=
(bbox.CalcDiagonalLength() + (p2 - p1).Length());
}
return false;
}
void MeshGrid::CalculateGridLength (unsigned long ulCtGrid, unsigned long ulMaxGrids)
{
// Grid Laengen bzw. Anzahl der Grids pro Dimension berechnen
// pro Grid sollen ca. 10 (?!?!) Facets liegen
// bzw. max Grids sollten 10000 nicht ueberschreiten
Base::BoundBox3f clBBMeshEnlarged = _pclMesh->GetBoundBox();
float fVolElem;
if (_ulCtElements > (ulMaxGrids * ulCtGrid))
fVolElem = (clBBMeshEnlarged.LengthX() * clBBMeshEnlarged.LengthY() * clBBMeshEnlarged.LengthZ()) / float(ulMaxGrids * ulCtGrid);
else
fVolElem = (clBBMeshEnlarged.LengthX() * clBBMeshEnlarged.LengthY() * clBBMeshEnlarged.LengthZ()) / float(_ulCtElements);
float fVol = fVolElem * float(ulCtGrid);
float fGridLen = float(pow((float)fVol,(float) 1.0f / 3.0f));
_ulCtGridsX = std::max<unsigned long>((unsigned long)(clBBMeshEnlarged.LengthX() / fGridLen), 1);
_ulCtGridsY = std::max<unsigned long>((unsigned long)(clBBMeshEnlarged.LengthY() / fGridLen), 1);
_ulCtGridsZ = std::max<unsigned long>((unsigned long)(clBBMeshEnlarged.LengthZ() / fGridLen), 1);
}
Base::BoundBox3f Edgesort::getBoundingBox(std::vector<TopoDS_Edge>& aList)
{
std::vector<TopoDS_Edge>::iterator aListIt;
//Fill Bounding Boxes with Edges
//Therefore we have to evaluate some points on our wire and feed the BBox Algorithm
Base::BoundBox3f currentBox;
currentBox.Flush();
for (aListIt = aList.begin();aListIt!=aList.end();aListIt++)
{
BRepAdaptor_Curve curveAdaptor(*aListIt);
GCPnts_QuasiUniformDeflection aProp(curveAdaptor,0.1);
Base::Vector3f aPoint;
for (int j=1;j<=aProp.NbPoints();++j)
{
aPoint.x = aProp.Value(j).X();
aPoint.y = aProp.Value(j).Y();
aPoint.z = aProp.Value(j).Z();
currentBox.Add(aPoint);
}
}
return currentBox;
}
PyObject* MeshPy::nearestFacetOnRay(PyObject *args)
{
PyObject* pnt_p;
PyObject* dir_p;
if (!PyArg_ParseTuple(args, "OO", &pnt_p, &dir_p))
return NULL;
try {
Py::Tuple pnt_t(pnt_p);
Py::Tuple dir_t(dir_p);
Py::Dict dict;
Base::Vector3f pnt((float)Py::Float(pnt_t.getItem(0)),
(float)Py::Float(pnt_t.getItem(1)),
(float)Py::Float(pnt_t.getItem(2)));
Base::Vector3f dir((float)Py::Float(dir_t.getItem(0)),
(float)Py::Float(dir_t.getItem(1)),
(float)Py::Float(dir_t.getItem(2)));
unsigned long index = 0;
Base::Vector3f res;
MeshCore::MeshAlgorithm alg(getMeshObjectPtr()->getKernel());
#if 0 // for testing only
MeshCore::MeshFacetGrid grid(getMeshObjectPtr()->getKernel(),10);
// With grids we might search in the opposite direction, too
if (alg.NearestFacetOnRay(pnt, dir, grid, res, index) ||
alg.NearestFacetOnRay(pnt, -dir, grid, res, index)) {
#else
if (alg.NearestFacetOnRay(pnt, dir, res, index)) {
#endif
Py::Tuple tuple(3);
tuple.setItem(0, Py::Float(res.x));
tuple.setItem(1, Py::Float(res.y));
tuple.setItem(2, Py::Float(res.z));
dict.setItem(Py::Int((int)index), tuple);
}
#if 0 // for testing only
char szBuf[200];
std::ofstream str("grid_test.iv");
Base::InventorBuilder builder(str);
MeshCore::MeshGridIterator g_it(grid);
for (g_it.Init(); g_it.More(); g_it.Next()) {
Base::BoundBox3f box = g_it.GetBoundBox();
unsigned long uX,uY,uZ;
g_it.GetGridPos(uX,uY,uZ);
builder.addBoundingBox(Base::Vector3f(box.MinX,box.MinY, box.MinZ),
Base::Vector3f(box.MaxX,box.MaxY, box.MaxZ));
sprintf(szBuf, "(%lu,%lu,%lu)", uX, uY, uZ);
builder.addText(box.CalcCenter(), szBuf);
}
builder.addSingleArrow(pnt-20.0f*dir, pnt+10.0f*dir);
builder.close();
str.close();
#endif
return Py::new_reference_to(dict);
}
catch (const Py::Exception&) {
return 0;
}
}
unsigned long MeshFacetGrid::SearchNearestFromPoint (const Base::Vector3f &rclPt) const
{
unsigned long ulFacetInd = ULONG_MAX;
float fMinDist = FLOAT_MAX;
Base::BoundBox3f clBB = GetBoundBox();
if (clBB.IsInBox(rclPt) == true)
{ // Punkt liegt innerhalb
unsigned long ulX, ulY, ulZ;
Position(rclPt, ulX, ulY, ulZ);
float fMinGridDist = std::min<float>(std::min<float>(_fGridLenX, _fGridLenY), _fGridLenZ);
unsigned long ulDistance = 0;
while (fMinDist > (fMinGridDist * float(ulDistance)))
{
SearchNearestFacetInHull(ulX, ulY, ulZ, ulDistance, rclPt, ulFacetInd, fMinDist);
ulDistance++;
}
SearchNearestFacetInHull(ulX, ulY, ulZ, ulDistance, rclPt, ulFacetInd, fMinDist);
}
else
{ // Punkt ausserhalb
Base::BoundBox3f::SIDE tSide = clBB.GetSideFromRay(rclPt, clBB.CalcCenter() - rclPt);
switch (tSide)
{
case Base::BoundBox3f::RIGHT:
{
int nX = 0;
while ((fMinDist > ((clBB.MinX - rclPt.x) + ((float)(nX) * _fGridLenX))) && ((unsigned long)(nX) < _ulCtGridsX))
{
for (unsigned long i = 0; i < _ulCtGridsY; i++)
{
for (unsigned long j = 0; j < _ulCtGridsZ; j++)
SearchNearestFacetInGrid(nX, i, j, rclPt, fMinDist, ulFacetInd);
}
nX++;
}
break;
}
case Base::BoundBox3f::LEFT:
{
int nX = _ulCtGridsX - 1;
while ((fMinDist > ((rclPt.x - clBB.MinX) + (float(nX) * _fGridLenX))) && (nX >= 0))
{
for (unsigned long i = 0; i < _ulCtGridsY; i++)
{
for (unsigned long j = 0; j < _ulCtGridsZ; j++)
SearchNearestFacetInGrid(nX, i, j, rclPt, fMinDist, ulFacetInd);
}
nX--;
}
break;
}
case Base::BoundBox3f::TOP:
{
int nY = 0;
while ((fMinDist > ((clBB.MinY - rclPt.y) + ((float)(nY) * _fGridLenY))) && ((unsigned long)(nY) < _ulCtGridsY))
{
for (unsigned long i = 0; i < _ulCtGridsX; i++)
{
for (unsigned long j = 0; j < _ulCtGridsZ; j++)
SearchNearestFacetInGrid(i, nY, j, rclPt, fMinDist, ulFacetInd);
}
nY++;
}
break;
}
case Base::BoundBox3f::BOTTOM:
{
int nY = _ulCtGridsY - 1;
while ((fMinDist > ((rclPt.y - clBB.MinY) + (float(nY) * _fGridLenY))) && (nY >= 0))
{
for (unsigned long i = 0; i < _ulCtGridsX; i++)
{
for (unsigned long j = 0; j < _ulCtGridsZ; j++)
SearchNearestFacetInGrid(i, nY, j, rclPt, fMinDist, ulFacetInd);
}
nY--;
}
break;
}
case Base::BoundBox3f::BACK:
{
int nZ = 0;
while ((fMinDist > ((clBB.MinZ - rclPt.z) + ((float)(nZ) * _fGridLenZ))) && ((unsigned long)(nZ) < _ulCtGridsZ))
{
for (unsigned long i = 0; i < _ulCtGridsX; i++)
{
for (unsigned long j = 0; j < _ulCtGridsY; j++)
SearchNearestFacetInGrid(i, j, nZ, rclPt, fMinDist, ulFacetInd);
}
nZ++;
}
break;
}
case Base::BoundBox3f::FRONT:
{
int nZ = _ulCtGridsZ - 1;
while ((fMinDist > ((rclPt.z - clBB.MinZ) + ((float)(nZ) * _fGridLenZ))) && (nZ >= 0))
{
for (unsigned long i = 0; i < _ulCtGridsX; i++)
{
for (unsigned long j = 0; j < _ulCtGridsY; j++)
SearchNearestFacetInGrid(i, j, nZ, rclPt, fMinDist, ulFacetInd);
}
nZ--;
}
break;
}
default:
break;
}
}
return ulFacetInd;
}
void MeshGrid::SearchNearestFromPoint (const Base::Vector3f &rclPt, std::set<unsigned long> &raclInd) const
{
raclInd.clear();
Base::BoundBox3f clBB = GetBoundBox();
if (clBB.IsInBox(rclPt) == true)
{ // Punkt liegt innerhalb
unsigned long ulX, ulY, ulZ;
Position(rclPt, ulX, ulY, ulZ);
//int nX = ulX, nY = ulY, nZ = ulZ;
unsigned long ulLevel = 0;
while (raclInd.size() == 0)
GetHull(ulX, ulY, ulZ, ulLevel++, raclInd);
GetHull(ulX, ulY, ulZ, ulLevel, raclInd);
}
else
{ // Punkt ausserhalb
Base::BoundBox3f::SIDE tSide = clBB.GetSideFromRay(rclPt, clBB.CalcCenter() - rclPt);
switch (tSide)
{
case Base::BoundBox3f::RIGHT:
{
int nX = 0;
while (raclInd.size() == 0)
{
for (unsigned long i = 0; i < _ulCtGridsY; i++)
{
for (unsigned long j = 0; j < _ulCtGridsZ; j++)
raclInd.insert(_aulGrid[nX][i][j].begin(), _aulGrid[nX][i][j].end());
}
nX++;
}
break;
}
case Base::BoundBox3f::LEFT:
{
int nX = _ulCtGridsX - 1;
while (raclInd.size() == 0)
{
for (unsigned long i = 0; i < _ulCtGridsY; i++)
{
for (unsigned long j = 0; j < _ulCtGridsZ; j++)
raclInd.insert(_aulGrid[nX][i][j].begin(), _aulGrid[nX][i][j].end());
}
nX++;
}
break;
}
case Base::BoundBox3f::TOP:
{
int nY = 0;
while (raclInd.size() == 0)
{
for (unsigned long i = 0; i < _ulCtGridsX; i++)
{
for (unsigned long j = 0; j < _ulCtGridsZ; j++)
raclInd.insert(_aulGrid[i][nY][j].begin(), _aulGrid[i][nY][j].end());
}
nY++;
}
break;
}
case Base::BoundBox3f::BOTTOM:
{
int nY = _ulCtGridsY - 1;
while (raclInd.size() == 0)
{
for (unsigned long i = 0; i < _ulCtGridsX; i++)
{
for (unsigned long j = 0; j < _ulCtGridsZ; j++)
raclInd.insert(_aulGrid[i][nY][j].begin(), _aulGrid[i][nY][j].end());
}
nY--;
}
break;
}
case Base::BoundBox3f::BACK:
{
int nZ = 0;
while (raclInd.size() == 0)
{
for (unsigned long i = 0; i < _ulCtGridsX; i++)
{
for (unsigned long j = 0; j < _ulCtGridsY; j++)
raclInd.insert(_aulGrid[i][j][nZ].begin(), _aulGrid[i][j][nZ].end());
}
nZ++;
}
break;
}
case Base::BoundBox3f::FRONT:
{
int nZ = _ulCtGridsZ - 1;
while (raclInd.size() == 0)
{
for (unsigned long i = 0; i < _ulCtGridsX; i++)
{
for (unsigned long j = 0; j < _ulCtGridsY; j++)
raclInd.insert(_aulGrid[i][j][nZ].begin(), _aulGrid[i][j][nZ].end());
}
nZ--;
}
break;
}
default:
break;
}
}
}
void MeshGrid::CalculateGridLength (int iCtGridPerAxis)
{
if (iCtGridPerAxis<=0)
{
CalculateGridLength(MESH_CT_GRID, MESH_MAX_GRIDS);
return;
}
// Grid Laengen bzw. Anzahl der Grids pro Dimension berechnen
// pro Grid sollen ca. 10 (?!?!) Facets liegen
// bzw. max Grids sollten 10000 nicht ueberschreiten
Base::BoundBox3f clBBMesh = _pclMesh->GetBoundBox();
float fLenghtX = clBBMesh.LengthX();
float fLenghtY = clBBMesh.LengthY();
float fLenghtZ = clBBMesh.LengthZ();
float fLenghtD = clBBMesh.CalcDiagonalLength();
float fLengthTol = 0.05f * fLenghtD;
bool bLenghtXisZero = (fLenghtX <= fLengthTol);
bool bLenghtYisZero = (fLenghtY <= fLengthTol);
bool bLenghtZisZero = (fLenghtZ <= fLengthTol);
int iFlag = 0;
int iMaxGrids = 1;
if (bLenghtXisZero)
iFlag += 1;
else
iMaxGrids *= iCtGridPerAxis;
if (bLenghtYisZero)
iFlag += 2;
else
iMaxGrids *= iCtGridPerAxis;
if (bLenghtZisZero)
iFlag += 4;
else
iMaxGrids *= iCtGridPerAxis;
unsigned long ulGridsFacets = 10;
float fFactorVolumen = 40.0;
float fFactorArea = 10.0;
switch (iFlag)
{
case 0:
{
float fVolumen = fLenghtX * fLenghtY * fLenghtZ;
float fVolumenGrid = (fVolumen * ulGridsFacets) / (fFactorVolumen * _ulCtElements);
if ((fVolumenGrid * iMaxGrids) < fVolumen)
fVolumenGrid = fVolumen / (float)iMaxGrids;
float fLengthGrid = float(pow((float)fVolumenGrid,(float) 1.0f / 3.0f));
_ulCtGridsX = std::max<unsigned long>((unsigned long)(fLenghtX / fLengthGrid), 1);
_ulCtGridsY = std::max<unsigned long>((unsigned long)(fLenghtY / fLengthGrid), 1);
_ulCtGridsZ = std::max<unsigned long>((unsigned long)(fLenghtZ / fLengthGrid), 1);
} break;
case 1:
{
_ulCtGridsX = 1; // bLenghtXisZero
float fArea = fLenghtY * fLenghtZ;
float fAreaGrid = (fArea * ulGridsFacets) / (fFactorArea * _ulCtElements);
if ((fAreaGrid * iMaxGrids) < fArea)
fAreaGrid = fArea / (float)iMaxGrids;
float fLengthGrid = float(sqrt(fAreaGrid));
_ulCtGridsY = std::max<unsigned long>((unsigned long)(fLenghtY / fLengthGrid), 1);
_ulCtGridsZ = std::max<unsigned long>((unsigned long)(fLenghtZ / fLengthGrid), 1);
} break;
case 2:
{
_ulCtGridsY = 1; // bLenghtYisZero
float fArea = fLenghtX * fLenghtZ;
float fAreaGrid = (fArea * ulGridsFacets) / (fFactorArea * _ulCtElements);
if ((fAreaGrid * iMaxGrids) < fArea)
fAreaGrid = fArea / (float)iMaxGrids;
float fLengthGrid = float(sqrt(fAreaGrid));
_ulCtGridsX = std::max<unsigned long>((unsigned long)(fLenghtX / fLengthGrid), 1);
_ulCtGridsZ = std::max<unsigned long>((unsigned long)(fLenghtZ / fLengthGrid), 1);
} break;
case 3:
{
_ulCtGridsX = 1; // bLenghtXisZero
_ulCtGridsY = 1; // bLenghtYisZero
_ulCtGridsZ = iMaxGrids; // bLenghtYisZero
} break;
case 4:
{
_ulCtGridsZ = 1; // bLenghtZisZero
float fArea = fLenghtX * fLenghtY;
float fAreaGrid = (fArea * ulGridsFacets) / (fFactorArea * _ulCtElements);
if ((fAreaGrid * iMaxGrids) < fArea)
fAreaGrid = fArea / (float)iMaxGrids;
float fLengthGrid = float(sqrt(fAreaGrid));
_ulCtGridsX = std::max<unsigned long>((unsigned long)(fLenghtX / fLengthGrid), 1);
_ulCtGridsY = std::max<unsigned long>((unsigned long)(fLenghtY / fLengthGrid), 1);
} break;
case 5:
{
_ulCtGridsX = 1; // bLenghtXisZero
_ulCtGridsZ = 1; // bLenghtZisZero
_ulCtGridsY = iMaxGrids; // bLenghtYisZero
} break;
case 6:
{
_ulCtGridsY = 1; // bLenghtYisZero
_ulCtGridsZ = 1; // bLenghtZisZero
_ulCtGridsX = iMaxGrids; // bLenghtYisZero
} break;
case 7:
{
_ulCtGridsX = iMaxGrids; // bLenghtXisZero
_ulCtGridsY = iMaxGrids; // bLenghtYisZero
_ulCtGridsZ = iMaxGrids; // bLenghtZisZero
} break;
}
}
