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; } }