//------------------------------------------------------------------------------ // Description: // Returns the double array static void GetDoubleArrayByName( const hid_t rootIdx, const char *name, std::vector<double> &array) { // turn off warnings void *pContext = NULL; H5E_auto_t erorFunc; H5Eget_auto(&erorFunc, &pContext); H5Eset_auto(NULL, NULL); hid_t arrayIdx = H5Dopen(rootIdx, name); if (arrayIdx < 0) { vtkGenericWarningMacro("Cannot open array: " << name << "\n"); return; } // turn warnings back on H5Eset_auto(erorFunc, pContext); pContext = NULL; // get the number of particles hsize_t dimValus[3]; hid_t spaceIdx = H5Dget_space(arrayIdx); H5Sget_simple_extent_dims(spaceIdx, dimValus, NULL); int numbPnts = dimValus[0]; array.resize(numbPnts); H5Dread(arrayIdx, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, &array[0]); // H5Dclose( spaceIdx ); // H5Dclose( arrayIdx ); }
//------------------------------------------------------------------------------ // Description: // Finds the block index (blockIndx) within the HDF5 file associated with // the given file index. static bool FindBlockIndex(hid_t fileIndx, const int blockIdx, hid_t &rootIndx) { // retrieve the contents of the root directory to look for a group // corresponding to the target block, if available, open that group hsize_t numbObjs; rootIndx = H5Gopen(fileIndx, "/"); if (rootIndx < 0) { vtkGenericWarningMacro("Failed to open root node of particles file"); return false; } bool found = false; H5Gget_num_objs(rootIndx, &numbObjs); for (int objIndex = 0; objIndex < static_cast < int >(numbObjs); objIndex++) { if (H5Gget_objtype_by_idx(rootIndx, objIndex) == H5G_GROUP) { int blckIndx; char blckName[65]; H5Gget_objname_by_idx(rootIndx, objIndex, blckName, 64); // Is this the target block? if ((sscanf(blckName, "Grid%d", &blckIndx) == 1) && (blckIndx == blockIdx)) { // located the target block rootIndx = H5Gopen(rootIndx, blckName); if (rootIndx < 0) { vtkGenericWarningMacro("Could not locate target block!\n"); } found = true; break; } } // END if group } // END for all objects return (found); }
void StackedImageDataLIC3D::SimpleExecute(vtkImageData * input, vtkImageData * output) { vtkDataArray * vectors = input->GetPointData()->GetVectors(); if (!vectors) { vtkGenericWarningMacro("StackeImageDataLIC3D::SimpleExecute: missing input vectors"); return; } initialize(); auto appendTo3D = vtkSmartPointer<vtkImageAppend>::New(); appendTo3D->SetAppendAxis(2); int inputExtent[6]; input->GetExtent(inputExtent); for (int position = inputExtent[4]; position < inputExtent[5]; ++position) { int sliceExtent[6]; input->GetExtent(sliceExtent); sliceExtent[4] = sliceExtent[5] = position; auto slice = vtkSmartPointer<vtkExtractVOI>::New(); slice->SetVOI(sliceExtent); slice->SetInputData(input); auto lic2D = vtkSmartPointer<vtkImageDataLIC2D>::New(); lic2D->SetInputConnection(0, slice->GetOutputPort()); lic2D->SetInputConnection(1, m_noiseImage->GetOutputPort()); lic2D->SetSteps(50); lic2D->GlobalWarningDisplayOff(); lic2D->SetContext(m_glContext); appendTo3D->AddInputConnection(lic2D->GetOutputPort()); } appendTo3D->Update(); output->DeepCopy(appendTo3D->GetOutput()); }
VTK_THREAD_RETURN_TYPE vtkVisItStreamLine::ThreadedIntegrate( void *arg) { vtkVisItStreamLine *self; int thread_count; int thread_id; vtkStreamer::StreamArray *streamer; vtkStreamer::StreamPoint *sNext = 0, *sPtr; vtkStreamer::StreamPoint pt1, pt2; int i; vtkIdType idxNext, ptId; double d, step, dir; double xNext[3], vel[3], *cellVel, derivs[9]; double *w, pcoords[3]; double coords[4]; vtkDataSet *input; vtkGenericCell *cell; vtkPointData *pd; vtkDataArray *inScalars; vtkDataArray *inVectors; vtkDoubleArray *cellVectors; vtkDataArray *cellScalars=0; double tOffset, vort[3]; double err; int nSavePts = 0, counter=0; thread_id = ((vtkMultiThreader::ThreadInfo *)(arg))->ThreadID; thread_count = ((vtkMultiThreader::ThreadInfo *)(arg))->NumberOfThreads; self = (vtkVisItStreamLine *)(((vtkMultiThreader::ThreadInfo *)(arg))->UserData); input = vtkDataSet::SafeDownCast(self->GetInput()); pd = input->GetPointData(); inScalars = pd->GetScalars(); inVectors = pd->GetVectors(); cell = vtkGenericCell::New(); cellVectors = vtkDoubleArray::New(); cellVectors->SetNumberOfComponents(3); cellVectors->Allocate(3*VTK_CELL_SIZE); if (inScalars) { cellScalars = inScalars->NewInstance(); cellScalars->SetNumberOfComponents(inScalars->GetNumberOfComponents()); cellScalars->Allocate(inScalars->GetNumberOfComponents()*VTK_CELL_SIZE); } // Set the function set to be integrated vtkInterpolatedVelocityField* func = vtkInterpolatedVelocityField::New(); func->AddDataSet(input); if (self->GetIntegrator() == 0) { vtkGenericWarningMacro("No integrator is specified."); return VTK_THREAD_RETURN_VALUE; } w = new double[input->GetMaxCellSize()]; // Create a new integrator, the type is the same as Integrator vtkInitialValueProblemSolver* integrator = self->GetIntegrator()->NewInstance(); integrator->SetFunctionSet(func); // Used to avoid calling these function many times during // the integration double termspeed = self->GetTerminalSpeed(); double maxtime = self->GetMaximumPropagationTime(); double savePointInterval = self->GetSavePointInterval(); // Take the largest of 2*maxtime or 100. It's simply an artificial // limit to the number of times to iterate to break out of a loop that // looks infinite. int MAX_ITERATIONS = int(maxtime * 2.); MAX_ITERATIONS = (MAX_ITERATIONS < 100) ? 100 : MAX_ITERATIONS; // For each streamer, integrate in appropriate direction // Do only the streamers that this thread should handle. for (ptId=0; ptId < self->GetNumberOfStreamers(); ptId++) { if(ptId % thread_count == thread_id) { // Get starting step streamer = self->GetStreamers() + ptId; sPtr = streamer->GetStreamPoint(0); if(sPtr->cellId < 0) { continue; } // Set the last cell id in the vtkInterpolatedVelocityField // object to speed up FindCell calls func->SetLastCellId(sPtr->cellId); dir = streamer->Direction; // Copy the first point pt1 = *sPtr; pt2 = *sPtr; tOffset = pt1.t; //integrate until time has been exceeded int iterations = 0; while(pt1.cellId >= 0 && pt1.speed > termspeed && pt1.t < maxtime && iterations < MAX_ITERATIONS) { if(counter++ % 1000 == 0) { if (!thread_id) { self->UpdateProgress((double)ptId/self->GetNumberOfStreamers() +pt1.t/maxtime/self->GetNumberOfStreamers()); } if (self->GetAbortExecute()) { break; } } // Set the integration step to be characteristic cell length // time IntegrationStepLength input->GetCell(pt1.cellId, cell); step = dir * self->GetIntegrationStepLength() * sqrt((double)cell->GetLength2())/pt1.speed; // Calculate the next step using the integrator provided if (integrator->ComputeNextStep(pt1.x, pt1.v, xNext, 0, step, 0, err) != 0) { break; } for(i=0; i<3; i++) { coords[i] = xNext[i]; } // Interpolate the velocity field at coords if(!func->FunctionValues(coords, vel)) { break; } for(i=0; i<3; i++) { pt2.v[i] = vel[i]; } for (i=0; i<3; i++) { pt2.x[i] = xNext[i]; } pt2.cellId = func->GetLastCellId(); func->GetLastWeights(w); func->GetLastLocalCoordinates(pcoords); input->GetCell(pt2.cellId, cell); if(inScalars) { // Interpolate scalars inScalars->GetTuples(cell->PointIds, cellScalars); for (pt2.s=0.0, i=0; i < cell->GetNumberOfPoints(); i++) { pt2.s += cellScalars->GetComponent(i,0) * w[i]; } } pt2.speed = vtkMath::Norm(pt2.v); d = sqrt((double)vtkMath::Distance2BetweenPoints(pt1.x,pt2.x)); pt2.d = pt1.d + d; // If at stagnation region, stop the integration if(d == 0 || (pt1.speed + pt2.speed) < VTK_STREAMLINE_EPSILON) { pt2.t = pt1.t; break; } pt2.t = pt1.t + (2.0 * d / (pt1.speed + pt2.speed)); if (self->GetVorticity() && inVectors) { // compute vorticity inVectors->GetTuples(cell->PointIds, cellVectors); cellVel = cellVectors->GetPointer(0); cell->Derivatives(0, pcoords, cellVel, 3, derivs); vort[0] = derivs[7] - derivs[5]; vort[1] = derivs[2] - derivs[6]; vort[2] = derivs[3] - derivs[1]; // rotation pt2.omega = vtkMath::Dot(vort, pt2.v); pt2.omega /= pt2.speed; pt2.theta += (pt1.omega+pt2.omega)/2 * (pt2.t - pt1.t); } // Store only points which have a point to be displayed // between them if (tOffset >= pt1.t && tOffset <= pt2.t) { // Do not store if same as the last point. // To avoid storing some points twice. if(!sNext || sNext->x[0] != pt1.x[0] || sNext->x[1] != pt1.x[1] || sNext->x[2] != pt1.x[2]) { idxNext = streamer->InsertNextStreamPoint(); sNext = streamer->GetStreamPoint(idxNext); *sNext = pt1; nSavePts++; } idxNext = streamer->InsertNextStreamPoint(); sNext = streamer->GetStreamPoint(idxNext); *sNext = pt2; nSavePts++; } if (tOffset < pt2.t) { tOffset += ((int)(( pt2.t - tOffset) / savePointInterval) + 1) * savePointInterval; } pt1 = pt2; ++iterations; } // Store the last point anyway. if(!sNext || sNext->x[0] != pt2.x[0] || sNext->x[1] != pt2.x[1] || sNext->x[2] != pt2.x[2]) { idxNext = streamer->InsertNextStreamPoint(); sNext = streamer->GetStreamPoint(idxNext); *sNext = pt2; nSavePts++; } // Clear the last cell to avoid starting a search from // the last point in the streamline func->ClearLastCellId(); } } integrator->Delete(); func->Delete(); cell->Delete(); cellVectors->Delete(); if (cellScalars) { cellScalars->Delete(); } delete[] w; return VTK_THREAD_RETURN_VALUE; }
//---------------------------------------------------------------------------- void vesKiwiImageWidgetRepresentation::setSliceIndex(int planeIndex, int sliceIndex) { int dimensions[3]; this->imageData()->GetDimensions(dimensions); if (sliceIndex < 0) { sliceIndex = 0; } else if (sliceIndex >= dimensions[planeIndex]) { sliceIndex = dimensions[planeIndex] - 1; } // allocate images if needed if (planeIndex == 0) { if (!this->Internal->SliceImages[0]) { this->Internal->SliceImages[0] = vtkSmartPointer<vtkImageData>::New(); this->Internal->SliceImages[0]->SetOrigin(this->imageData()->GetOrigin()); this->Internal->SliceImages[0]->SetSpacing(this->imageData()->GetSpacing()); this->Internal->SliceImages[0]->SetDimensions(1, dimensions[1], dimensions[2]); this->Internal->SliceImages[0]->AllocateScalars(this->imageData()->GetScalarType(), 1); this->Internal->SliceImages[0]->GetPointData()->GetScalars()->SetName(this->imageData()->GetPointData()->GetScalars()->GetName()); } } else if (planeIndex == 1) { if (!this->Internal->SliceImages[1]) { this->Internal->SliceImages[1] = vtkSmartPointer<vtkImageData>::New(); this->Internal->SliceImages[1]->SetOrigin(this->imageData()->GetOrigin()); this->Internal->SliceImages[1]->SetSpacing(this->imageData()->GetSpacing()); this->Internal->SliceImages[1]->SetDimensions(dimensions[0], 1, dimensions[2]); this->Internal->SliceImages[1]->AllocateScalars(this->imageData()->GetScalarType(), 1); this->Internal->SliceImages[1]->GetPointData()->GetScalars()->SetName(this->imageData()->GetPointData()->GetScalars()->GetName()); } } else { if (!this->Internal->SliceImages[2]) { this->Internal->SliceImages[2] = vtkSmartPointer<vtkImageData>::New(); this->Internal->SliceImages[2]->SetOrigin(this->imageData()->GetOrigin()); this->Internal->SliceImages[2]->SetSpacing(this->imageData()->GetSpacing()); this->Internal->SliceImages[2]->SetDimensions(dimensions[0], dimensions[1], 1); this->Internal->SliceImages[2]->AllocateScalars(this->imageData()->GetScalarType(), 1); this->Internal->SliceImages[2]->GetPointData()->GetScalars()->SetName(this->imageData()->GetPointData()->GetScalars()->GetName()); } } vtkImageData* sliceImage = this->Internal->SliceImages[planeIndex]; #define mycall(vtktypename, vtkarraytype, primitivetype) \ case vtktypename: extractSliceExecute<vtkarraytype, primitivetype>(this->imageData(), sliceImage, planeIndex, sliceIndex); break; switch (this->imageData()->GetScalarType()) { mycall(VTK_CHAR, vtkCharArray, char); mycall(VTK_UNSIGNED_CHAR, vtkUnsignedCharArray, unsigned char); mycall(VTK_SHORT, vtkShortArray, short); mycall(VTK_UNSIGNED_SHORT,vtkUnsignedShortArray, unsigned short); mycall(VTK_INT, vtkIntArray, int); mycall(VTK_UNSIGNED_INT,vtkUnsignedIntArray, unsigned int); mycall(VTK_LONG, vtkLongArray, long); mycall(VTK_UNSIGNED_LONG,vtkUnsignedLongArray, unsigned long); mycall(VTK_FLOAT, vtkFloatArray, float); mycall(VTK_DOUBLE, vtkDoubleArray, double); mycall(VTK_ID_TYPE, vtkIdTypeArray, vtkIdType); default: vtkGenericWarningMacro("Execute: Unknown input ScalarType"); return; } vesKiwiImagePlaneDataRepresentation::Ptr rep = this->Internal->SliceReps[planeIndex]; rep->setImageData(sliceImage); this->Internal->AppendFilter->GetInput(planeIndex)->DeepCopy(rep->imagePlanePolyData()); this->Internal->CurrentSliceIndices[planeIndex] = sliceIndex; }