suzanne.soy/FreeCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

start node index interface

Browse Source
This commit is contained in:
jriegel 2013-09-12 21:55:32 +02:00
parent 9833d995e6
commit 866668ace0
5 changed files with 79 additions and 545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

538
src/Mod/Fem/App/AppFemPy.cpp
View File

@ -140,535 +140,6 @@ show(PyObject *self, PyObject *args)
}
//static PyObject * SMESH_PCA(PyObject *self, PyObject *args)
//{
// PyObject *input;
//
// if (!PyArg_ParseTuple(args, "O",&input))
// return NULL;
//
// PY_TRY {
//
// FemMeshPy *inputMesh = static_cast<FemMeshPy*>(input);
// MeshCore::MeshKernel aMesh;
// MeshCore::MeshPointArray vertices;
// vertices.clear();
// MeshCore::MeshFacetArray faces;
// faces.clear();
// MeshCore::MeshPoint current_node;
// SMDS_NodeIteratorPtr aNodeIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->nodesIterator();
// for (;aNodeIter->more();) {
// const SMDS_MeshNode* aNode = aNodeIter->next();
// current_node.Set(float(aNode->X()),float(aNode->Y()),float(aNode->Z()));
// vertices.push_back(current_node);
// }
//
// MeshCore::MeshFacet aFacet;
// aFacet._aulPoints[0] = 0;aFacet._aulPoints[1] = 1;aFacet._aulPoints[2] = 2;
// faces.push_back(aFacet);
// //Fill the Kernel with the temp smesh structure and delete the current containers
// aMesh.Adopt(vertices,faces);
// MeshCore::MeshEigensystem pca(aMesh);
// pca.Evaluate();
// Base::Matrix4D Trafo = pca.Transform();
// /*Let´s transform the input mesh with the PCA Matrix*/
// inputMesh->getFemMeshPtr()->transformGeometry(Trafo);
// //inputMesh->getFemMeshPtr()->getSMesh()->ExportUNV("C:/Temp/PCA_alignment.unv");
// //Now lets check if the smallest dimension of the BBox is oriented towards the Z-Axis. If not, lets rotate it around the X or Y axis
// //Use the SMESH structure for that
// // aMesh.Transform(Trafo);
//
// //Base::Rotation rotatex,rotatey,rotatez;
// //const Base::Vector3d rotate_axis_x(1.0,0.0,0.0),rotate_axis_y(0.0,1.0,0.0),rotate_axis_z(0.0,0.0,1.0);
// //double bbox_length_x,bbox_length_y,bbox_length_z;
// ////Rotate around the each axes and choose the settings for the min bbox
// //Base::Matrix4D final_trafo;
// //Base::BoundBox3f aBBox;
// ////Get the current BBOX and look for the size
// //aBBox = aMesh.GetBoundBox();
// //bbox_length_x = aBBox.LengthX();bbox_length_y = aBBox.LengthY();bbox_length_z = aBBox.LengthZ();
// ////Now do the rotation stuff
// //if (bbox_length_z < bbox_length_x && bbox_length_z < bbox_length_y)
// // Py_Return;
// //else if (
//
//
// //MeshCore::MeshKernel atempkernel;
//
// //float it_steps=10.0;
// //double step_size;
// //double alpha_x=0.0,alpha_y=0.0,alpha_z=0.0;
// //double perfect_ax=0.0,perfect_ay=0.0,perfect_az=0.0;
//
// ////Do a Monte Carlo approach and start from the Principal Axis System
// ////and rotate +/- 60° around each axis in a first iteration
// //double angle_range_min_x=-PI/3.0,angle_range_max_x=PI/3.0,
// // angle_range_min_y=-PI/3.0,angle_range_max_y=PI/3.0,
// // angle_range_min_z=-PI/3.0,angle_range_max_z=PI/3.0;
//
// ////We rotate until we are 0.1° sure to be in the right position
// //for (step_size = (2.0*PI/it_steps);step_size>(2.0*PI/3600.0);step_size=(2.0*PI/it_steps))
// //{
// // for(alpha_x=angle_range_min_x;alpha_x<angle_range_max_x;alpha_x=alpha_x+step_size)
// // {
// // rotatex.setValue(rotate_axis_x,alpha_x);
// // for(alpha_y=angle_range_min_y;alpha_y<angle_range_max_y;alpha_y=alpha_y+step_size)
// // {
// // rotatey.setValue(rotate_axis_y,alpha_y);
// // for(alpha_z=angle_range_min_z;alpha_z<angle_range_max_z;alpha_z=alpha_z+step_size)
// // {
// // rotatez.setValue(rotate_axis_z,alpha_z);
// // (rotatex*rotatey*rotatez).getValue(final_trafo);
// // atempkernel = aMesh;
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// } PY_CATCH;
//
// Py_Return;
//}
//static PyObject * calcMeshVolume(PyObject *self, PyObject *args)
//{
// PyObject *input;
//
// if (!PyArg_ParseTuple(args, "O",&input))
// return NULL;
//
// PY_TRY {
//
// FemMeshPy *inputMesh = static_cast<FemMeshPy*>(input);
//
// SMDS_VolumeIteratorPtr aVolIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->volumesIterator();
// Base::Vector3d a,b,c,a_b_product,temp,temp1;
// double volume =0.0;
// for (;aVolIter->more();)
// {
// const SMDS_MeshVolume* aVol = aVolIter->next();
// //To make sure that the volume calculation is based on the ABAQUS element convention
// //The following Node mapping from SMESH to ABAQUS is necessary
// //ABAQUS_Node_Number|SMESH_Node_Number
// //0|0
// //1|2
// //2|1
// //3|3
// //4|6
// //5|5
// //6|4
// //7|8
// //8|9
// //9|7
// //The following coordinates of the little pyramids are based on ABAQUS convention and are numbered from
// //1 to 10
// //1,5,8,7
// temp.Set(aVol->GetNode(6)->X(),aVol->GetNode(6)->Y(),aVol->GetNode(6)->Z());
// temp1.Set(aVol->GetNode(0)->X(),aVol->GetNode(0)->Y(),aVol->GetNode(0)->Z());
// a = temp - temp1;
// temp.Set(aVol->GetNode(8)->X(),aVol->GetNode(8)->Y(),aVol->GetNode(8)->Z());
// temp1.Set(aVol->GetNode(0)->X(),aVol->GetNode(0)->Y(),aVol->GetNode(0)->Z());
// b = temp - temp1;
// temp.Set(aVol->GetNode(4)->X(),aVol->GetNode(4)->Y(),aVol->GetNode(4)->Z());
// temp1.Set(aVol->GetNode(0)->X(),aVol->GetNode(0)->Y(),aVol->GetNode(0)->Z());
// c = temp - temp1;
// a_b_product.x = a.y*b.z-b.y*a.z;a_b_product.y = a.z*b.x-b.z*a.x;a_b_product.z = a.x*b.y-b.x*a.y;
// volume += 1.0/6.0 * fabs((a_b_product.x * c.x)+ (a_b_product.y * c.y)+(a_b_product.z * c.z));
// //5,9,8,7
// temp.Set(aVol->GetNode(9)->X(),aVol->GetNode(9)->Y(),aVol->GetNode(9)->Z());
// temp1.Set(aVol->GetNode(6)->X(),aVol->GetNode(6)->Y(),aVol->GetNode(6)->Z());
// a = temp - temp1;
// temp.Set(aVol->GetNode(8)->X(),aVol->GetNode(8)->Y(),aVol->GetNode(8)->Z());
// temp1.Set(aVol->GetNode(6)->X(),aVol->GetNode(6)->Y(),aVol->GetNode(6)->Z());
// b = temp - temp1;
// temp.Set(aVol->GetNode(4)->X(),aVol->GetNode(4)->Y(),aVol->GetNode(4)->Z());
// temp1.Set(aVol->GetNode(6)->X(),aVol->GetNode(6)->Y(),aVol->GetNode(6)->Z());
// c = temp - temp1;
// a_b_product.x = a.y*b.z-b.y*a.z;a_b_product.y = a.z*b.x-b.z*a.x;a_b_product.z = a.x*b.y-b.x*a.y;
// volume += 1.0/6.0 * fabs((a_b_product.x * c.x)+ (a_b_product.y * c.y)+(a_b_product.z * c.z));
// //5,2,9,7
// temp.Set(aVol->GetNode(2)->X(),aVol->GetNode(2)->Y(),aVol->GetNode(2)->Z());
// temp1.Set(aVol->GetNode(6)->X(),aVol->GetNode(6)->Y(),aVol->GetNode(6)->Z());
// a = temp - temp1;
// temp.Set(aVol->GetNode(9)->X(),aVol->GetNode(9)->Y(),aVol->GetNode(9)->Z());
// temp1.Set(aVol->GetNode(6)->X(),aVol->GetNode(6)->Y(),aVol->GetNode(6)->Z());
// b = temp - temp1;
// temp.Set(aVol->GetNode(4)->X(),aVol->GetNode(4)->Y(),aVol->GetNode(4)->Z());
// temp1.Set(aVol->GetNode(6)->X(),aVol->GetNode(6)->Y(),aVol->GetNode(6)->Z());
// c = temp - temp1;
// a_b_product.x = a.y*b.z-b.y*a.z;a_b_product.y = a.z*b.x-b.z*a.x;a_b_product.z = a.x*b.y-b.x*a.y;
// volume += 1.0/6.0 * fabs((a_b_product.x * c.x)+ (a_b_product.y * c.y)+(a_b_product.z * c.z));
// //2,6,9,7
// temp.Set(aVol->GetNode(5)->X(),aVol->GetNode(5)->Y(),aVol->GetNode(5)->Z());
// temp1.Set(aVol->GetNode(2)->X(),aVol->GetNode(2)->Y(),aVol->GetNode(2)->Z());
// a = temp - temp1;
// temp.Set(aVol->GetNode(9)->X(),aVol->GetNode(9)->Y(),aVol->GetNode(9)->Z());
// temp1.Set(aVol->GetNode(2)->X(),aVol->GetNode(2)->Y(),aVol->GetNode(2)->Z());
// b = temp - temp1;
// temp.Set(aVol->GetNode(4)->X(),aVol->GetNode(4)->Y(),aVol->GetNode(4)->Z());
// temp1.Set(aVol->GetNode(2)->X(),aVol->GetNode(2)->Y(),aVol->GetNode(2)->Z());
// c = temp - temp1;
// a_b_product.x = a.y*b.z-b.y*a.z;a_b_product.y = a.z*b.x-b.z*a.x;a_b_product.z = a.x*b.y-b.x*a.y;
// volume += 1.0/6.0 * fabs((a_b_product.x * c.x)+ (a_b_product.y * c.y)+(a_b_product.z * c.z));
// //9,6,10,7
// temp.Set(aVol->GetNode(5)->X(),aVol->GetNode(5)->Y(),aVol->GetNode(5)->Z());
// temp1.Set(aVol->GetNode(9)->X(),aVol->GetNode(9)->Y(),aVol->GetNode(9)->Z());
// a = temp - temp1;
// temp.Set(aVol->GetNode(7)->X(),aVol->GetNode(7)->Y(),aVol->GetNode(7)->Z());
// temp1.Set(aVol->GetNode(9)->X(),aVol->GetNode(9)->Y(),aVol->GetNode(9)->Z());
// b = temp - temp1;
// temp.Set(aVol->GetNode(4)->X(),aVol->GetNode(4)->Y(),aVol->GetNode(4)->Z());
// temp1.Set(aVol->GetNode(9)->X(),aVol->GetNode(9)->Y(),aVol->GetNode(9)->Z());
// c = temp - temp1;
// a_b_product.x = a.y*b.z-b.y*a.z;a_b_product.y = a.z*b.x-b.z*a.x;a_b_product.z = a.x*b.y-b.x*a.y;
// volume += 1.0/6.0 * fabs((a_b_product.x * c.x)+ (a_b_product.y * c.y)+(a_b_product.z * c.z));
// //6,3,10,7
// temp.Set(aVol->GetNode(1)->X(),aVol->GetNode(1)->Y(),aVol->GetNode(1)->Z());
// temp1.Set(aVol->GetNode(5)->X(),aVol->GetNode(5)->Y(),aVol->GetNode(5)->Z());
// a = temp - temp1;
// temp.Set(aVol->GetNode(7)->X(),aVol->GetNode(7)->Y(),aVol->GetNode(7)->Z());
// temp1.Set(aVol->GetNode(5)->X(),aVol->GetNode(5)->Y(),aVol->GetNode(5)->Z());
// b = temp - temp1;
// temp.Set(aVol->GetNode(4)->X(),aVol->GetNode(4)->Y(),aVol->GetNode(4)->Z());
// temp1.Set(aVol->GetNode(5)->X(),aVol->GetNode(5)->Y(),aVol->GetNode(5)->Z());
// c = temp - temp1;
// a_b_product.x = a.y*b.z-b.y*a.z;a_b_product.y = a.z*b.x-b.z*a.x;a_b_product.z = a.x*b.y-b.x*a.y;
// volume += 1.0/6.0 * fabs((a_b_product.x * c.x)+ (a_b_product.y * c.y)+(a_b_product.z * c.z));
// //8,9,10,7
// temp.Set(aVol->GetNode(9)->X(),aVol->GetNode(9)->Y(),aVol->GetNode(9)->Z());
// temp1.Set(aVol->GetNode(8)->X(),aVol->GetNode(8)->Y(),aVol->GetNode(8)->Z());
// a = temp - temp1;
// temp.Set(aVol->GetNode(7)->X(),aVol->GetNode(7)->Y(),aVol->GetNode(7)->Z());
// temp1.Set(aVol->GetNode(8)->X(),aVol->GetNode(8)->Y(),aVol->GetNode(8)->Z());
// b = temp - temp1;
// temp.Set(aVol->GetNode(4)->X(),aVol->GetNode(4)->Y(),aVol->GetNode(4)->Z());
// temp1.Set(aVol->GetNode(8)->X(),aVol->GetNode(8)->Y(),aVol->GetNode(8)->Z());
// c = temp - temp1;
// a_b_product.x = a.y*b.z-b.y*a.z;a_b_product.y = a.z*b.x-b.z*a.x;a_b_product.z = a.x*b.y-b.x*a.y;
// volume += 1.0/6.0 * fabs((a_b_product.x * c.x)+ (a_b_product.y * c.y)+(a_b_product.z * c.z));
// //8,9,10,4
// temp.Set(aVol->GetNode(9)->X(),aVol->GetNode(9)->Y(),aVol->GetNode(9)->Z());
// temp1.Set(aVol->GetNode(8)->X(),aVol->GetNode(8)->Y(),aVol->GetNode(8)->Z());
// a = temp - temp1;
// temp.Set(aVol->GetNode(7)->X(),aVol->GetNode(7)->Y(),aVol->GetNode(7)->Z());
// temp1.Set(aVol->GetNode(8)->X(),aVol->GetNode(8)->Y(),aVol->GetNode(8)->Z());
// b = temp - temp1;
// temp.Set(aVol->GetNode(3)->X(),aVol->GetNode(3)->Y(),aVol->GetNode(3)->Z());
// temp1.Set(aVol->GetNode(8)->X(),aVol->GetNode(8)->Y(),aVol->GetNode(8)->Z());
// c = temp - temp1;
// a_b_product.x = a.y*b.z-b.y*a.z;a_b_product.y = a.z*b.x-b.z*a.x;a_b_product.z = a.x*b.y-b.x*a.y;
// volume += 1.0/6.0 * fabs((a_b_product.x * c.x)+ (a_b_product.y * c.y)+(a_b_product.z * c.z));
// }
// Py::Float py_volume(volume);
// return Py::new_reference_to(py_volume);
//
// } PY_CATCH;
//
// Py_Return;
//}
//static PyObject * checkBB(PyObject *self, PyObject *args)
//{
// PyObject *input;
// PyObject* plm=0;
// float billet_thickness;
// bool oversize = false;
//
// if (!PyArg_ParseTuple(args, "O|O!f", &input,&(Base::PlacementPy::Type),&plm,&billet_thickness))
// return NULL;
//
// try {
// Base::Placement* placement = 0;
// if (plm) {
// placement = static_cast<Base::PlacementPy*>(plm)->getPlacementPtr();
//
// }
// Base::Vector3d current_node;
// Base::Matrix4D matrix = placement->toMatrix();
// FemMeshPy *inputMesh = static_cast<FemMeshPy*>(input);
// SMDS_NodeIteratorPtr aNodeIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->nodesIterator();
// for (;aNodeIter->more();) {
// const SMDS_MeshNode* aNode = aNodeIter->next();
// current_node.Set(float(aNode->X()),float(aNode->Y()),float(aNode->Z()));
// current_node = matrix * current_node;
// if(current_node.z > billet_thickness || current_node.z < -0.1)
// {
// //lets jump out of the function as soon as we find a
// //Node that is higher or lower than billet thickness
// oversize = true;
// Py::Boolean py_oversize(oversize);
// return Py::new_reference_to(py_oversize);
// }
// }
// Py::Boolean py_oversize(oversize);
// return Py::new_reference_to(py_oversize);
// }
// catch (const std::exception& e) {
// PyErr_SetString(PyExc_Exception, e.what());
// return 0;
// }
// Py_Return;
//}
//
//
//
//
//static PyObject * getBoundary_Conditions(PyObject *self, PyObject *args)
//{
// PyObject *input;
// Py::List boundary_nodes;
//
// if (!PyArg_ParseTuple(args, "O!", &(FemMeshPy::Type), &input))
// //if (!PyArg_ParseTuple(args, "O",&input))
// return NULL;
//
// PY_TRY {
//
// FemMeshPy *inputMesh = static_cast<FemMeshPy*>(input);
// MeshCore::MeshKernel aMesh;
// MeshCore::MeshPointArray vertices;
// vertices.clear();
// MeshCore::MeshFacetArray faces;
// faces.clear();
// MeshCore::MeshPoint current_node;
// SMDS_NodeIteratorPtr aNodeIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->nodesIterator();
// SMDS_VolumeIteratorPtr aVolIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->volumesIterator();
// for (;aNodeIter->more();) {
// const SMDS_MeshNode* aNode = aNodeIter->next();
// current_node.Set(float(aNode->X()),float(aNode->Y()),float(aNode->Z()));
// vertices.push_back(current_node);
// }
// MeshCore::MeshFacet aFacet;
// aFacet._aulPoints[0] = 0;aFacet._aulPoints[1] = 1;aFacet._aulPoints[2] = 2;
// faces.push_back(aFacet);
// //Fill the Kernel with the temp smesh structure and delete the current containers
// aMesh.Adopt(vertices,faces);
// Base::BoundBox3f aBBox;
// aBBox = aMesh.GetBoundBox();
//
// float dist_length;
// Base::Vector3f dist;
// int minNodeID,maxNodeID,midNodeID;
// dist_length = FLOAT_MAX;
//
// aVolIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->volumesIterator();
// //We only search in non midside nodes (equals the first four nodes of each element)
// for (;aVolIter->more();)
// {
// const SMDS_MeshVolume* aVol = aVolIter->next();
// for (unsigned j=0;j<4;j++)
// {
// const SMDS_MeshNode* aNode = aVol->GetNode(j);
// //Calc distance between the lower left corner and the most next point of the mesh
// dist.x = float(aNode->X())-aBBox.MinX;dist.y = float(aNode->Y())-aBBox.MinY;dist.z = float(aNode->Z())-aBBox.MinZ;
// if(dist.Length()<dist_length)
// {
// minNodeID = aNode->GetID();
// dist_length = dist.Length();
// }
// }
// }
//
// boundary_nodes.append(Py::Int(minNodeID));
//
// dist_length = FLOAT_MAX;
// aVolIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->volumesIterator();
// for (;aVolIter->more();)
// {
// const SMDS_MeshVolume* aVol = aVolIter->next();
// for (unsigned j=0;j<4;j++)
// {
// const SMDS_MeshNode* aNode = aVol->GetNode(j);
// //Calc distance between the lower right corner and the most next point of the mesh
// dist.x = float(aNode->X())-aBBox.MaxX;dist.y = float(aNode->Y())-aBBox.MinY;dist.z = float(aNode->Z())-aBBox.MinZ;
// if(dist.Length()<dist_length)
// {
// midNodeID = aNode->GetID();
// dist_length = dist.Length();
// }
// }
// }
// boundary_nodes.append(Py::Int(midNodeID));
//
// dist_length = FLOAT_MAX;
// aVolIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->volumesIterator();
// for (;aVolIter->more();)
// {
// const SMDS_MeshVolume* aVol = aVolIter->next();
// for (unsigned j=0;j<4;j++)
// {
// const SMDS_MeshNode* aNode = aVol->GetNode(j);
// //Calc distance between the lowest lower right corner and the most next point of the mesh
// dist.x = float(aNode->X())-aBBox.MinX;dist.y = float(aNode->Y())-aBBox.MaxY;dist.z = float(aNode->Z())-aBBox.MinZ;
// if(dist.Length()<dist_length)
// {
// maxNodeID = aNode->GetID();
// dist_length = dist.Length();
// }
// }
// }
// boundary_nodes.append(Py::Int(maxNodeID));
//
//
//
//
// return Py::new_reference_to(boundary_nodes);
//
//
// } PY_CATCH;
//
// Py_Return;
//}
//static PyObject * minBoundingBox(PyObject *self, PyObject *args)
//{
//
// PyObject *input;
//
// if (!PyArg_ParseTuple(args, "O",&input))
// return NULL;
//
// PY_TRY {
// FemMeshPy *inputMesh = static_cast<FemMeshPy*>(input);
// MeshCore::MeshKernel aMesh;
// MeshCore::MeshPointArray vertices;
// vertices.clear();
// MeshCore::MeshFacetArray faces;
// faces.clear();
// MeshCore::MeshPoint current_node;
// SMDS_NodeIteratorPtr aNodeIter = inputMesh->getFemMeshPtr()->getSMesh()->GetMeshDS()->nodesIterator();
// for (;aNodeIter->more();) {
// const SMDS_MeshNode* aNode = aNodeIter->next();
// current_node.Set(float(aNode->X()),float(aNode->Y()),float(aNode->Z()));
// vertices.push_back(current_node);
// }
// MeshCore::MeshFacet aFacet;
// aFacet._aulPoints[0] = 0;aFacet._aulPoints[1] = 1;aFacet._aulPoints[2] = 2;
// faces.push_back(aFacet);
// //Fill the Kernel with the temp smesh structure and delete the current containers
// aMesh.Adopt(vertices,faces);
//
// ///////////////////////////////////////////////////////////////////////////
// //Now do Monte Carlo to minimize the BBox of the part
// //Use Quaternions for the rotation stuff
// Base::Rotation rotatex,rotatey,rotatez;
// const Base::Vector3d rotate_axis_x(1.0,0.0,0.0),rotate_axis_y(0.0,1.0,0.0),rotate_axis_z(0.0,0.0,1.0);
//
// //Rotate around each axes and choose the settings for the min bbox
// Base::Matrix4D final_trafo;
// Base::BoundBox3f aBBox,min_bbox;
// double volumeBBOX,min_volumeBBOX;
// //Get the current min_volumeBBOX and look if we find a lower one
// aBBox = aMesh.GetBoundBox();
// min_volumeBBOX = aBBox.LengthX()*aBBox.LengthY()*aBBox.LengthZ();
//
// MeshCore::MeshKernel atempkernel;
//
// float it_steps=10.0;
// double step_size;
// double alpha_x=0.0,alpha_y=0.0,alpha_z=0.0;
// double perfect_ax=0.0,perfect_ay=0.0,perfect_az=0.0;
//
// //Do a Monte Carlo approach and start from the Principal Axis System
// //and rotate +/- 60° around each axis in a first iteration
// double angle_range_min_x=-M_PI/3.0,angle_range_max_x=M_PI/3.0,
// angle_range_min_y=-M_PI/3.0,angle_range_max_y=M_PI/3.0,
// angle_range_min_z=-M_PI/3.0,angle_range_max_z=M_PI/3.0;
//
// //We rotate until we are 0.1° sure to be in the right position
// for (step_size = (2.0*M_PI/it_steps);step_size>(2.0*M_PI/3600.0);step_size=(2.0*M_PI/it_steps))
// {
// for(alpha_x=angle_range_min_x;alpha_x<angle_range_max_x;alpha_x=alpha_x+step_size)
// {
// rotatex.setValue(rotate_axis_x,alpha_x);
// for(alpha_y=angle_range_min_y;alpha_y<angle_range_max_y;alpha_y=alpha_y+step_size)
// {
// rotatey.setValue(rotate_axis_y,alpha_y);
// for(alpha_z=angle_range_min_z;alpha_z<angle_range_max_z;alpha_z=alpha_z+step_size)
// {
// rotatez.setValue(rotate_axis_z,alpha_z);
// (rotatex*rotatey*rotatez).getValue(final_trafo);
// atempkernel = aMesh;
// atempkernel.Transform(final_trafo);
// aBBox = atempkernel.GetBoundBox();
// volumeBBOX = aBBox.LengthX()*aBBox.LengthY()*aBBox.LengthZ();
// if (volumeBBOX < min_volumeBBOX)
// {
// min_volumeBBOX=volumeBBOX;
// perfect_ax=alpha_x;
// perfect_ay=alpha_y;
// perfect_az=alpha_z;
// }
// }
// }
// }
// //We found a better position than the PAS, now lets fine tune this position
// //and search only in the corridor +/- step_size for an even better one
// angle_range_min_x = perfect_ax - step_size;
// angle_range_max_x = perfect_ax + step_size;
// angle_range_min_y = perfect_ay - step_size;
// angle_range_max_y = perfect_ay + step_size;
// angle_range_min_z = perfect_az - step_size;
// angle_range_max_z = perfect_az + step_size;
// it_steps = it_steps*float(5.0);
// }
//
// //////////////////////////////////////////////////////////////////////////////////////
// //Free Memory
// atempkernel.Clear();
// //Transform the mesh to the evaluated perfect position right now
// rotatex.setValue(rotate_axis_x,perfect_ax);
// rotatey.setValue(rotate_axis_y,perfect_ay);
// rotatez.setValue(rotate_axis_z,perfect_az);
// (rotatex*rotatey*rotatez).getValue(final_trafo);
// aMesh.Transform(final_trafo);
// inputMesh->getFemMeshPtr()->transformGeometry(final_trafo);
// //////////////////////////////////////////////////////////////////////////////////////
// //Now lets also do the movement to the 1st Quadrant in this function
// aBBox = aMesh.GetBoundBox();
// //Get Distance vector from current lower left corner of BBox to origin
// Base::Vector3f dist_vector;
// dist_vector.x = -aBBox.MinX;dist_vector.y=-aBBox.MinY;dist_vector.z=-aBBox.MinZ;
// Base::Matrix4D trans_matrix(
// float(1.0),float(0.0),float(0.0),dist_vector.x,
// float(0.0),float(1.0),float(0.0),dist_vector.y,
// float(0.0),float(0.0),float(1.0),dist_vector.z,
// float(0.0),float(0.0),float(0.0),float(1.0));
// inputMesh->getFemMeshPtr()->transformGeometry(trans_matrix);
//
// //inputMesh->getFemMeshPtr()->getSMesh()->ExportUNV("C:/temp/fine_tuning.unv");
//
// } PY_CATCH;
//
// Py_Return;
//}
static PyObject * importer(PyObject *self, PyObject *args)
@ -1105,14 +576,5 @@ struct PyMethodDef Fem_methods[] = {
{"read" ,read, Py_NEWARGS, "Read a mesh from a file and returns a Mesh object."},
{"show" ,show ,METH_VARARGS,
"show(shape) -- Add the shape to the active document or create one if no document exists."},
// {"calcMeshVolume", calcMeshVolume, Py_NEWARGS,
// "Calculate Mesh Volume for C3D10"},
// {"getBoundary_Conditions" , getBoundary_Conditions, Py_NEWARGS,
// "Get Boundary Conditions for Residual Stress Calculation"},
//{"SMESH_PCA" , SMESH_PCA, Py_NEWARGS,
// "Get a Matrix4D related to the PCA of a Mesh Object"},
//{"import_NASTRAN",import_NASTRAN, Py_NEWARGS, "Import Nastran files, for tests only. Use read() or insert()"},
//{"minBoundingBox",minBoundingBox,Py_NEWARGS,"Minimize the Bounding Box and reorient the mesh to the 1st Quadrant"},
//{"checkBB",checkBB,Py_NEWARGS,"Check if the nodal z-values are still in the prescribed range"},
{NULL, NULL} /* sentinel */
};

17
src/Mod/Fem/App/FemMeshPy.xml
View File

@ -84,12 +84,17 @@
<UserDocu>Make a copy of this FEM mesh.</UserDocu>
</Documentation>
</Methode>
<Methode Name="getNodeById">
<Documentation>
<UserDocu>Get the node position vector by an Node-ID</UserDocu>
</Documentation>
</Methode>
<Attribute Name="Nodes" ReadOnly="true">
<Methode Name="getNodeById">
<Documentation>
<UserDocu>Get the node position vector by an Node-ID</UserDocu>
</Documentation>
</Methode>
<Methode Name="getNodesByFace">
<Documentation>
<UserDocu>Return a list of node IDs which belong to a TopoFace</UserDocu>
</Documentation>
</Methode>
<Attribute Name="Nodes" ReadOnly="true">
<Documentation>
<UserDocu>Dictionary of Nodes by ID (int ID:Vector())</UserDocu>
</Documentation>

27
src/Mod/Fem/App/FemMeshPyImp.cpp
View File

@ -29,12 +29,14 @@
#include <SMDS_VolumeTool.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Face.hxx>
#include <Base/VectorPy.h>
#include <Base/MatrixPy.h>
#include <Base/PlacementPy.h>
#include <Mod/Part/App/TopoShapePy.h>
#include <Mod/Part/App/TopoShapeFacePy.h>
#include <Mod/Part/App/TopoShape.h>
#include "Mod/Fem/App/FemMesh.h"
@ -479,6 +481,31 @@ PyObject* FemMeshPy::getNodeById(PyObject *args)
}
}
PyObject* FemMeshPy::getNodesByFace(PyObject *args)
{
PyObject *pW;
if (!PyArg_ParseTuple(args, "O!", &(Part::TopoShapeFacePy::Type), &pW))
return 0;
try {
const TopoDS_Shape& sh = static_cast<Part::TopoShapeFacePy*>(pW)->getTopoShapePtr()->_Shape;
if (sh.IsNull()) {
PyErr_SetString(PyExc_Exception, "Face is empty");
return 0;
}
Py::List ret;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
}
// ===== Atributes ============================================================

7
src/Mod/Part/App/TopoShapePy.xml
View File

@ -321,7 +321,12 @@ Boolean indicates if the point lying directly on a face is considered to be insi
<UserDocu>Removes redundant edges from the B-REP model</UserDocu>
</Documentation>
</Methode>
<!--
<Methode Name="getElement" Const="true">
<Documentation>
<UserDocu>Returns a SubElement</UserDocu>
</Documentation>
</Methode>
<!--
<Attribute Name="Location" ReadOnly="false">
<Documentation>
<UserDocu>Gets or sets the local coordinate system of this shape.</UserDocu>

35
src/Mod/Part/App/TopoShapePyImp.cpp
View File

@ -1370,6 +1370,41 @@ PyObject* TopoShapePy::removeSplitter(PyObject *args)
}
}
PyObject* TopoShapePy::getElement(PyObject *args)
{
char* input;
if (!PyArg_ParseTuple(args, "s", &input))
return NULL;
std::string name(input);
try {
if (name.size() > 4 && name.substr(0,4) == "Face" && name[4]>=48 && name[4]<=57) {
std::auto_ptr<Part::ShapeSegment> s(static_cast<Part::ShapeSegment*>
(getTopoShapePtr()->getSubElementByName(input)));
TopoDS_Shape Shape = s->Shape;
return new TopoShapeFacePy(new TopoShape(Shape));
}
else if (name.size() > 4 && name.substr(0,4) == "Edge" && name[4]>=48 && name[4]<=57) {
std::auto_ptr<Part::ShapeSegment> s(static_cast<Part::ShapeSegment*>
(getTopoShapePtr()->getSubElementByName(input)));
TopoDS_Shape Shape = s->Shape;
return new TopoShapeEdgePy(new TopoShape(Shape));
}
else if (name.size() > 6 && name.substr(0,6) == "Vertex" && name[6]>=48 && name[6]<=57) {
std::auto_ptr<Part::ShapeSegment> s(static_cast<Part::ShapeSegment*>
(getTopoShapePtr()->getSubElementByName(input)));
TopoDS_Shape Shape = s->Shape;
return new TopoShapeVertexPy(new TopoShape(Shape));
}
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
PyErr_SetString(PyExc_Exception, e->GetMessageString());
return 0;
}
return 0;
}
#if 0 // see ComplexGeoDataPy::Matrix which does the same
Py::Object TopoShapePy::getLocation(void) const
{