vtkSmartPointer<vtkArrayType> FlowAnalysis::vtkMakeArray(const vtkSmartPointer<vtkUniformGrid>& grid, const string& name, size_t numComponents, bool fillZero){
auto arr=vtkSmartPointer<vtkArrayType>::New();
arr->SetNumberOfComponents(numComponents);
arr->SetNumberOfTuples(boxCells.prod());
arr->SetName(name.c_str());
if(cellData) grid->GetCellData()->AddArray(arr);
else grid->GetPointData()->AddArray(arr);
if(fillZero){ for(int _i=0; _i<(int)numComponents; _i++) arr->FillComponent(_i,0.); }
return arr;
}
void VTKEulerMeshSnapshotWriter::dumpMeshSpecificData(EulerMesh* mesh, vtkSmartPointer<vtkStructuredGrid>& grid, vtkSmartPointer<vtkPoints>& points) const
{
auto nodeDims = mesh->getNodeDimensions();
auto cellDims = mesh->getDimensions();
auto cellStatus = vtkSmartPointer<vtkIntArray>::New();
cellStatus->SetName("cellStatus");
auto cellError = vtkSmartPointer<vtkIntArray>::New();
cellError->SetName("cellError");
for (uint k = 0; k < nodeDims.z; k++)
for (uint j = 0; j < nodeDims.y; j++)
for (uint i = 0; i < nodeDims.x; i++)
{
auto& node = mesh->getNodeByEulerMeshIndex(vector3u(i, j, k));
points->InsertNextPoint(node.coords.x, node.coords.y, node.coords.z);
}
for (uint k = 0; k < cellDims.z; k++)
for (uint j = 0; j < cellDims.y; j++)
for (uint i = 0; i < cellDims.x; i++)
{
cellStatus->InsertNextValue(mesh->getCellStatus(vector3u(i, j, k)));
char flag = 0;
for (uint p = 0; p <= 1; p++)
for (uint q = 0; q <= 1; q++)
for (uint s = 0; s <= 1; s++)
if ((flag = mesh->getNodeByEulerMeshIndex(vector3u(i+p, j+q, k+s)).getErrorFlags()))
break;
cellError->InsertNextValue(flag);
}
grid->GetCellData()->AddArray(cellStatus);
grid->GetCellData()->AddArray(cellError);
grid->SetDimensions(nodeDims.x, nodeDims.y, nodeDims.z);
}
void
pcl::io::pointCloudTovtkPolyData(const pcl::PCLPointCloud2Ptr& cloud, vtkSmartPointer<vtkPolyData>& poly_data)
{
if (!poly_data.GetPointer())
poly_data = vtkSmartPointer<vtkPolyData>::New (); // OR poly_data->Reset();
// Add Points
size_t x_idx = pcl::getFieldIndex (*cloud, std::string ("x") );
vtkSmartPointer<vtkPoints> cloud_points = vtkSmartPointer<vtkPoints>::New ();
vtkSmartPointer<vtkCellArray> cloud_vertices = vtkSmartPointer<vtkCellArray>::New ();
vtkIdType pid[1];
for (size_t point_idx = 0; point_idx < cloud->width * cloud->height; point_idx ++)
{
float point[3];
int point_offset = (int (point_idx) * cloud->point_step);
int offset = point_offset + cloud->fields[x_idx].offset;
memcpy (&point, &cloud->data[offset], sizeof (float)*3);
pid[0] = cloud_points->InsertNextPoint (point);
cloud_vertices->InsertNextCell (1, pid);
}
//set the points and vertices we created as the geometry and topology of the polydata
poly_data->SetPoints (cloud_points);
poly_data->SetVerts (cloud_vertices);
// Add RGB
int rgb_idx = pcl::getFieldIndex (*cloud, "rgb");
if (rgb_idx != -1)
{
//std::cout << "Adding rgb" << std::endl;
vtkSmartPointer<vtkUnsignedCharArray> colors = vtkSmartPointer<vtkUnsignedCharArray>::New ();
colors->SetNumberOfComponents (3);
colors->SetName ("rgb");
for (size_t point_idx = 0; point_idx < cloud->width * cloud->height; point_idx ++)
{
unsigned char bgr[3];
int point_offset = (int (point_idx) * cloud->point_step);
int offset = point_offset + cloud->fields[rgb_idx].offset;
memcpy (&bgr, &cloud->data[offset], sizeof (unsigned char)*3);
colors->InsertNextTuple3(bgr[2], bgr[1], bgr[0]);
}
poly_data->GetCellData()->SetScalars(colors);
}
// Add Intensity
int intensity_idx = pcl::getFieldIndex (*cloud, "intensity");
if (intensity_idx != -1)
{
//std::cout << "Adding intensity" << std::endl;
vtkSmartPointer<vtkFloatArray> cloud_intensity = vtkSmartPointer<vtkFloatArray>::New ();
cloud_intensity->SetNumberOfComponents (1);
cloud_intensity->SetName("intensity");
for (size_t point_idx = 0; point_idx < cloud->width * cloud->height; point_idx ++)
{
float intensity;
int point_offset = (int (point_idx) * cloud->point_step);
int offset = point_offset + cloud->fields[intensity_idx].offset;
memcpy (&intensity, &cloud->data[offset], sizeof(float));
cloud_intensity->InsertNextValue(intensity);
}
poly_data->GetCellData()->AddArray(cloud_intensity);
if (rgb_idx == -1)
poly_data->GetCellData()->SetActiveAttribute("intensity", vtkDataSetAttributes::SCALARS);
}
// Add Normals
int normal_x_idx = pcl::getFieldIndex (*cloud, std::string ("normal_x") );
if (normal_x_idx != -1)
{
//std::cout << "Adding normals" << std::endl;
vtkSmartPointer<vtkFloatArray> normals = vtkSmartPointer<vtkFloatArray>::New();
normals->SetNumberOfComponents(3); //3d normals (ie x,y,z)
normals->SetName("normals");
for (size_t point_idx = 0; point_idx < cloud->width * cloud->height; point_idx ++)
{
float normal[3];
int point_offset = (int (point_idx) * cloud->point_step);
int offset = point_offset + cloud->fields[normal_x_idx].offset;
memcpy (&normal, &cloud->data[offset], sizeof (float)*3);
normals->InsertNextTuple(normal);
}
poly_data->GetCellData()->SetNormals(normals);
//poly_data->GetCellData()->SetActiveAttribute("normals", vtkDataSetAttributes::SCALARS);
}
}
void
ExporterVTK<MeshType,N>::saveElementData( typename timeset_type::step_ptrtype step, Iterator __evar, Iterator __evaren, vtkSmartPointer<vtkout_type> out ) const
{
while ( __evar != __evaren )
{
if ( !__evar->second.worldComm().isActive() ) return;
auto mesh = step->mesh();
auto r = elements( step->mesh() );
auto elt_st = r.template get<1>();
auto elt_en = r.template get<2>();
if ( !__evar->second.areGlobalValuesUpdated() )
__evar->second.updateGlobalValues();
//size_type ncells = __evar->second.size()/__evar->second.nComponents;
size_type ncells = std::distance( elt_st, elt_en );
uint16_type nComponents = __evar->second.nComponents;
if ( __evar->second.is_vectorial )
nComponents = 3;
size_type __field_size = nComponents * ncells;
std::vector<float> __field( __field_size );
__field.clear();
DVLOG(2) << "[saveElement] firstLocalIndex = " << __evar->second.firstLocalIndex() << "\n";
DVLOG(2) << "[saveElement] lastLocalIndex = " << __evar->second.lastLocalIndex() << "\n";
DVLOG(2) << "[saveElement] field.size = " << __field_size << "\n";
vtkSmartPointer<vtkFloatArray> da = vtkSmartPointer<vtkFloatArray>::New();
da->SetName(__evar->first.c_str());
/* set array parameters */
da->SetNumberOfComponents(nComponents);
da->SetNumberOfTuples(ncells);
/*
std::cout << this->worldComm().rank() << " nbElts:" << ncells << " nComp:" << nComponents
<< " __evar->second.nComponents:" << __evar->second.nComponents << std::endl;
*/
/*
std::cout << this->worldComm().rank() << " marker=" << *mit << " nbElts:" << ncells << " nComp:" << nComponents
<< " __evar->second.nComponents:" << __evar->second.nComponents << std::endl;
*/
float * array = new float[nComponents];
size_type e = 0;
for ( auto elt_it = elt_st ; elt_it != elt_en; ++elt_it, ++e )
{
auto const& elt = boost::unwrap_ref( *elt_it );
DVLOG(2) << "pid : " << this->worldComm().globalRank()
<< " elt_it : " << elt.id()
<< " e : " << e << "\n";
for ( int c = 0; c < nComponents; ++c )
{
size_type global_node_id = e*ncells+c ;
if ( c < __evar->second.nComponents )
{
size_type dof_id = boost::get<0>( __evar->second.functionSpace()->dof()->localToGlobal( elt.id(),0, c ) );
DVLOG(2) << "c : " << c
<< " gdofid: " << global_node_id
<< " dofid : " << dof_id
<< " f.size : " << __field.size()
<< " e.size : " << __evar->second.size()
<< "\n";
//__field[global_node_id] = __evar->second.globalValue( dof_id );
array[c] = __evar->second.globalValue( dof_id );
#if 1
//__field[global_node_id] = __evar->second.globalValue(dof_id);
DVLOG(2) << "c : " << c
<< " gdofid: " << global_node_id
<< " dofid : " << dof_id
<< " field : " << __field[global_node_id]
<< " evar: " << __evar->second.globalValue( dof_id ) << "\n";
#endif
}
else
{
//__field[global_node_id] = 0;
array[c] = 0.0;
}
}
da->SetTuple(e, array);
}
delete[] array;
/* add data array into the vtk object */
out->GetCellData()->AddArray(da);
/* Set the first scalar/vector/tensor data, we process as active */
if( __evar->second.is_scalar && !(out->GetCellData()->GetScalars()))
{
out->GetCellData()->SetActiveScalars(da->GetName());
}
if( __evar->second.is_vectorial && !(out->GetCellData()->GetVectors()))
{
out->GetCellData()->SetActiveVectors(da->GetName());
}
if( __evar->second.is_tensor2 && !(out->GetCellData()->GetTensors()))
{
out->GetCellData()->SetActiveTensors(da->GetName());
}
DVLOG(2) << "[ExporterVTK::saveElement] saving " << __evar->first << "done\n";
++__evar;
}
}
//keyword "cellvars" in OOFEM input file
void
VTKXMLExportModule :: exportCellVarAs(InternalStateType type, int region,
#ifdef __VTK_MODULE
vtkSmartPointer<vtkUnstructuredGrid> &stream,
#else
FILE *stream,
#endif
TimeStep *tStep)
{
Domain *d = emodel->giveDomain(1);
int ielem, nelem = d->giveNumberOfElements();
int pos;
Element *elem;
FloatMatrix mtrx(3, 3);
IntegrationRule *iRule;
GaussPoint *gp;
FloatArray answer, temp;
double gptot;
int ncomponents = 1;
#ifdef __VTK_MODULE
vtkSmartPointer<vtkDoubleArray> cellVarsArray = vtkSmartPointer<vtkDoubleArray>::New();
cellVarsArray->SetName(__InternalStateTypeToString(type));
#endif
switch ( type ) {
case IST_MaterialNumber:
case IST_ElementNumber:
case IST_Pressure:
// if it wasn't for IST_Pressure,
#ifdef __VTK_MODULE
cellVarsArray->SetNumberOfComponents(1);
cellVarsArray->SetNumberOfTuples(nelem);
#else
fprintf( stream, "<DataArray type=\"Float64\" Name=\"%s\" format=\"ascii\">\n", __InternalStateTypeToString(type) );
#endif
for ( ielem = 1; ielem <= nelem; ielem++ ) {
elem = d->giveElement(ielem);
if ( (( region > 0 ) && ( this->smoother->giveElementVirtualRegionNumber(ielem) != region ))
|| this->isElementComposite(elem) || !elem-> isActivated(tStep) ) { // composite cells exported individually
continue;
}
#ifdef __PARALLEL_MODE
if ( elem->giveParallelMode() != Element_local ) {
continue;
}
#endif
if ( type == IST_MaterialNumber ) {
#ifdef __VTK_MODULE
cellVarsArray->SetTuple1(ielem-1, elem->giveMaterial()->giveNumber() ); // Should be integer..
#else
fprintf( stream, "%d ", elem->giveMaterial()->giveNumber() );
#endif
} else if ( type == IST_ElementNumber ) {
#ifdef __VTK_MODULE
cellVarsArray->SetTuple1(ielem-1, elem->giveNumber() ); // Should be integer..
#else
fprintf( stream, "%d ", elem->giveNumber() );
#endif
} else if (type == IST_Pressure) { ///@todo Why this special treatment for pressure? / Mikael
if (elem->giveNumberOfInternalDofManagers() == 1) {
IntArray pmask(1); pmask.at(1) = P_f;
elem->giveInternalDofManager(1)->giveUnknownVector (answer, pmask,EID_ConservationEquation, VM_Total, tStep);
#ifdef __VTK_MODULE
cellVarsArray->SetTuple1(ielem-1, answer.at(1) ); // Should be integer..
#else
fprintf( stream, "%f ", answer.at(1) );
#endif
}
}
}
#ifdef __VTK_MODULE
stream->GetCellData()->SetActiveScalars(__InternalStateTypeToString(type));
stream->GetCellData()->SetScalars(cellVarsArray);
#endif
break;
case IST_MaterialOrientation_x:
case IST_MaterialOrientation_y:
case IST_MaterialOrientation_z:
#ifdef __VTK_MODULE
cellVarsArray->SetNumberOfComponents(3);
cellVarsArray->SetNumberOfTuples(nelem);
ncomponents = 3;
#else
fprintf( stream, "<DataArray type=\"Float64\" Name=\"%s\" NumberOfComponents=\"3\" format=\"ascii\">\n", __InternalStateTypeToString(type) );
#endif
if ( type == IST_MaterialOrientation_x ) {
pos = 1;
}
if ( type == IST_MaterialOrientation_y ) {
pos = 2;
}
if ( type == IST_MaterialOrientation_z ) {
pos = 3;
}
for ( ielem = 1; ielem <= nelem; ielem++ ) {
///@todo Should no elements be skipped here? / Mikael
if ( !d->giveElement(ielem)->giveLocalCoordinateSystem(mtrx) ) {
mtrx.resize(3, 3);
mtrx.zero();
}
#ifdef __VTK_MODULE
cellVarsArray->SetTuple3(ielem-1, mtrx.at(1, pos), mtrx.at(2,pos), mtrx.at(3,pos) );
#else
fprintf( stream, "%f %f %f ", mtrx.at(1, pos), mtrx.at(2, pos), mtrx.at(3, pos) );
#endif
}
#ifdef __VTK_MODULE
stream->GetCellData()->SetActiveVectors(__InternalStateTypeToString(type));
stream->GetCellData()->SetVectors(cellVarsArray);
#endif
break;
default:
bool reshape = false;
InternalStateValueType vt = giveInternalStateValueType(type);
if ( vt == ISVT_SCALAR ) {
ncomponents = 1;
} else if ( vt == ISVT_VECTOR ) {
ncomponents = 3;
} else {
ncomponents = 9;
reshape = true;
}
#ifdef __VTK_MODULE
cellVarsArray->SetNumberOfComponents(ncomponents);
cellVarsArray->SetNumberOfTuples(nelem);
#else
fprintf( stream, "<DataArray type=\"Float64\" Name=\"%s\" NumberOfComponents=\"%d\" format=\"ascii\">\n", __InternalStateTypeToString(type), ncomponents );
#endif
IntArray redIndx;
for ( ielem = 1; ielem <= nelem; ielem++ ) {
elem = d->giveElement(ielem);
if ( (( region > 0 ) && ( this->smoother->giveElementVirtualRegionNumber(ielem) != region ))
|| this->isElementComposite(elem) || !elem-> isActivated(tStep) ) { // composite cells exported individually
continue;
}
#ifdef __PARALLEL_MODE
if ( elem->giveParallelMode() != Element_local ) {
continue;
}
#endif
gptot = 0;
answer.resize(0);
iRule = elem->giveDefaultIntegrationRulePtr();
if (iRule) {
MaterialMode mmode = _Unknown;
for (int i = 0; i < iRule->getNumberOfIntegrationPoints(); ++i) {
gp = iRule->getIntegrationPoint(i);
mmode = gp->giveMaterialMode();
elem->giveIPValue(temp, gp, type, tStep);
gptot += gp->giveWeight();
answer.add(gp->giveWeight(), temp);
}
answer.times(1./gptot);
elem->giveMaterial()->giveIntVarCompFullIndx(redIndx, type, mmode);
}
// Reshape the Voigt vectors to include all components (duplicated if necessary, VTK insists on 9 components for tensors.)
if ( reshape && answer.giveSize() != 9) { // If it has 9 components, then it is assumed to be proper already.
FloatArray tmp = answer;
this->makeFullForm(answer, tmp, vt, redIndx);
} else if ( vt == ISVT_VECTOR && answer.giveSize() < 3) {
answer.setValues(3,
answer.giveSize() > 1 ? answer.at(1) : 0.0,
answer.giveSize() > 2 ? answer.at(2) : 0.0,
0.0);
} else if ( ncomponents != answer.giveSize() ) { // Trying to gracefully handle bad cases, just output zeros.
answer.resize(ncomponents);
answer.zero();
}
for (int i = 1; i <= ncomponents; ++i) {
#ifdef __VTK_MODULE
cellVarsArray->SetComponent(ielem-1, i-1, answer.at(i));
#else
fprintf( stream, "%e ", answer.at(i) );
#endif
}
#ifndef __VTK_MODULE
fprintf( stream, "\n" );
#endif
}
#ifdef __VTK_MODULE
if (ncomponents == 1) {
stream->GetCellData()->SetActiveScalars(__InternalStateTypeToString(type));
stream->GetCellData()->SetScalars(cellVarsArray);
} else if (ncomponents == 3) {
stream->GetCellData()->SetActiveVectors(__InternalStateTypeToString(type));
stream->GetCellData()->SetVectors(cellVarsArray);
} else {
stream->GetCellData()->SetActiveTensors(__InternalStateTypeToString(type));
stream->GetCellData()->SetTensors(cellVarsArray);
}
#endif
}
#ifndef __VTK_MODULE
fprintf(stream, "</DataArray>\n");
#endif
}