int LineOnPointsSelector2D::RequestData(vtkInformation * request,
vtkInformationVector ** inputVector,
vtkInformationVector * outputVector)
{
const int requestedPort = request->Get(vtkDemandDrivenPipeline::FROM_OUTPUT_PORT());
const bool generateSelection = requestedPort == 0;
const bool generateGeometry = requestedPort == 1;
vtkInformation * inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation * outSelectionInfo = outputVector->GetInformationObject(0);
vtkInformation * outPointExtractionInfo = outputVector->GetInformationObject(1);
auto inputPointSet = vtkPointSet::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
auto selectionOutput = vtkSelection::SafeDownCast(outSelectionInfo->Get(vtkDataObject::DATA_OBJECT()));
auto extractedOutput = vtkPolyData::SafeDownCast(outPointExtractionInfo->Get(vtkDataObject::DATA_OBJECT()));
auto inputPointData = inputPointSet->GetPointData();
auto extractionPointData = extractedOutput->GetPointData();
const vtkIdType numInputPoints = inputPointSet->GetNumberOfPoints();
if (numInputPoints == 0)
{
vtkWarningMacro(<< "LineOnPointsSelector2D: No points in input.");
return 1;
}
bool sm2ccConverter::addRGB(ccPointCloud * cloud)
{
assert(m_sm_cloud && cloud);
if (!m_sm_cloud || !cloud)
return false;
pcl::PointCloud<OnlyRGB>::Ptr pcl_cloud_rgb (new pcl::PointCloud<OnlyRGB>);
FROM_PCL_CLOUD(*m_sm_cloud, *pcl_cloud_rgb);
if (!cloud->reserveTheRGBTable())
return false;
size_t pointCount = GetNumberOfPoints(m_sm_cloud);
//loop
for (size_t i = 0; i < pointCount; ++i)
{
colorType C[3] = { (colorType)pcl_cloud_rgb->points[i].r,
(colorType)pcl_cloud_rgb->points[i].g,
(colorType)pcl_cloud_rgb->points[i].b};
cloud->addRGBColor(C);
}
cloud->showColors(true);
return true;
}
bool sm2ccConverter::addNormals(ccPointCloud *cloud)
{
assert(m_sm_cloud && cloud);
if (!m_sm_cloud || !cloud)
return false;
pcl::PointCloud<OnlyNormals>::Ptr pcl_cloud_normals (new pcl::PointCloud<OnlyNormals>);
FROM_PCL_CLOUD(*m_sm_cloud, *pcl_cloud_normals);
if (!cloud->reserveTheNormsTable())
return false;
size_t pointCount = GetNumberOfPoints(m_sm_cloud);
//loop
for (size_t i = 0; i < pointCount; ++i)
{
CCVector3 N( static_cast<PointCoordinateType>(pcl_cloud_normals->at(i).normal_x),
static_cast<PointCoordinateType>(pcl_cloud_normals->at(i).normal_y),
static_cast<PointCoordinateType>(pcl_cloud_normals->at(i).normal_z) );
cloud->addNorm(N);
}
cloud->showNormals(true);
return true;
}
bool sm2ccConverter::addXYZ(ccPointCloud *cloud)
{
assert(m_sm_cloud && cloud);
if (!m_sm_cloud || !cloud)
return false;
size_t pointCount = GetNumberOfPoints(m_sm_cloud);
if (!cloud->reserve(static_cast<unsigned>(pointCount)))
return false;
//add xyz to the given cloud taking xyz infos from the sm cloud
pcl::PointCloud<pcl::PointXYZ>::Ptr pcl_cloud (new pcl::PointCloud<pcl::PointXYZ>);
FROM_PCL_CLOUD(*m_sm_cloud, *pcl_cloud);
//loop
for (size_t i = 0; i < pointCount; ++i)
{
CCVector3 P(pcl_cloud->at(i).x,
pcl_cloud->at(i).y,
pcl_cloud->at(i).z);
cloud->addPoint(P);
}
return true;
}
//==== The Mouse Clicks Function =======================================//
void myMouseFunc(int button, int state, int x, int y){
Picker.onMouse(button,state,x,y);
delete [] xMtx;
delete [] yMtx;
xMtx = GetXMatrix();
yMtx = GetYMatrix();
n = GetNumberOfPoints();
}
int AssignPointAttributeToCoordinatesFilter::RequestData(
vtkInformation * /*request*/,
vtkInformationVector ** inputVector,
vtkInformationVector * outputVector)
{
auto inData = vtkPointSet::SafeDownCast(inputVector[0]->GetInformationObject(0)->Get(vtkDataObject::DATA_OBJECT()));
auto outData = vtkPointSet::SafeDownCast(outputVector->GetInformationObject(0)->Get(vtkDataObject::DATA_OBJECT()));
auto previousPointCoords = inData->GetPoints()->GetData();
vtkDataArray * pointsToAssign = nullptr;
if (!this->AttributeArrayToAssign.empty())
{
auto newPoints = inData->GetPointData()->GetArray(this->AttributeArrayToAssign.c_str());
if (!newPoints)
{
vtkErrorMacro("Array to assign not found in input data: " + this->AttributeArrayToAssign);
return 0;
}
if (newPoints->GetNumberOfComponents() != 3
|| newPoints->GetNumberOfTuples() != inData->GetNumberOfPoints())
{
vtkErrorMacro("Component/Tuple count mismatching in selected data array: " + this->AttributeArrayToAssign);
return 0;
}
pointsToAssign = newPoints;
}
outData->ShallowCopy(inData);
if (pointsToAssign)
{
vtkNew<vtkPoints> newPoints;
newPoints->SetData(pointsToAssign);
outData->SetPoints(newPoints.Get());
}
// pass current point coordinates as point attribute
if (previousPointCoords)
{
outData->GetPointData()->AddArray(previousPointCoords);
}
if (auto currentCoords = pointsToAssign ? pointsToAssign : previousPointCoords)
{
outData->GetPointData()->SetActiveScalars(currentCoords->GetName());
}
return 1;
}
std::pair<vtkSmartPointer<vtkMergePoints>,
std::unordered_map<vtkIdType, std::vector<graph_descriptor>>>
get_vtk_points_from_graphs(
const std::vector<std::reference_wrapper<const GraphType>> &graphs,
const BoundingBox *box) {
assert(graphs.size() > 0);
auto unique_points = vtkSmartPointer<vtkPoints>::New();
std::unordered_map<vtkIdType, std::vector<graph_descriptor>> unique_id_map;
// check vtkMergePoints with InsertUniquePoint
// The approach is to keep the points from get_vtk_points_from_graphs
// of the first graph
// vtkSmartPointer<vtkPointSet> pointSet =
// vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkMergePoints> mergePoints =
vtkSmartPointer<vtkMergePoints>::New();
vtkIdType lastPtId;
std::vector<PointsIdMapPair> graphs_point_map;
std::vector<double *> bounds_vector;
for(size_t graph_index = 0; graph_index < graphs.size(); ++graph_index) {
graphs_point_map.emplace_back(
get_vtk_points_from_graph(graphs[graph_index]));
const auto &points_per_graph = graphs_point_map.back().first;
bounds_vector.emplace_back(points_per_graph->GetBounds());
}
BoundingBox enclosing_box;
if(!box)
enclosing_box = BoundingBox::BuildEnclosingBox(bounds_vector);
else
enclosing_box = *box;
// Init the merger with points from the first graph
{
unique_points = graphs_point_map[0].first;
double bounds[6];
enclosing_box.GetBounds(bounds);
mergePoints->InitPointInsertion(unique_points, bounds);
// Insert the points
unique_id_map = graphs_point_map[0].second;
for(vtkIdType i = 0; i < unique_points->GetNumberOfPoints(); i++) {
mergePoints->InsertUniquePoint(unique_points->GetPoint(i), lastPtId);
}
}
for(size_t graph_index = 1; graph_index < graphs.size(); ++graph_index) {
append_new_graph_points(graphs_point_map[graph_index], mergePoints,
unique_id_map);
}
return std::make_pair(mergePoints, unique_id_map);
};
TEST_F(MatricesToVtk_Grid3D_test, read_points_from_vtkImageData)
{
auto image = vtkSmartPointer<vtkImageData>::New();
image->SetExtent(0, 2, 0, 3, 0, 2);
image->SetSpacing(0.1, 0.1, 0.1);
image->SetOrigin(-1.0, -2.0, -3.0);
io::ReadDataSet readDataSet;
readDataSet.type = io::DataSetType::vectorGrid3D;
auto & data = readDataSet.data;
const vtkIdType numPoints = image->GetNumberOfPoints();
// xyz (tested) + 3-component vector (not tested here)
data.resize(6, std::vector<io::t_FP>(static_cast<size_t>(numPoints)));
for (vtkIdType i = 0; i < numPoints; ++i)
{
const auto stdI = static_cast<size_t>(i);
vtkVector3d point;
image->GetPoint(i, point.GetData());
data[0u][stdI] = point.GetX();
data[1u][stdI] = point.GetY();
data[2u][stdI] = point.GetZ();
}
auto parsedImage = MatricesToVtk::loadGrid3D("TestingGrid3D", { readDataSet });
ASSERT_TRUE(parsedImage);
ASSERT_TRUE(parsedImage->dataSet());
ASSERT_EQ(numPoints, parsedImage->dataSet()->GetNumberOfPoints());
for (vtkIdType i = 0; i < numPoints; ++i)
{
vtkVector3d pRef, pParsed;
image->GetPoint(i, pRef.GetData());
parsedImage->dataSet()->GetPoint(i, pParsed.GetData());
ASSERT_DOUBLE_EQ(pRef.GetX(), pRef.GetX());
ASSERT_DOUBLE_EQ(pRef.GetY(), pRef.GetY());
ASSERT_DOUBLE_EQ(pRef.GetZ(), pRef.GetZ());
}
}
/**
Create the vtkStructuredGrid from the provided workspace
@param progressUpdating: Reporting object to pass progress information up the
stack.
@return fully constructed vtkDataSet.
*/
vtkSmartPointer<vtkDataSet>
vtkMDLineFactory::create(ProgressAction &progressUpdating) const {
auto product = tryDelegatingCreation<IMDEventWorkspace, 1>(m_workspace,
progressUpdating);
if (product != nullptr) {
return product;
} else {
g_log.warning() << "Factory " << this->getFactoryTypeName()
<< " is being used. You are viewing data with less than "
"three dimensions in the VSI. \n";
IMDEventWorkspace_sptr imdws =
doInitialize<IMDEventWorkspace, 1>(m_workspace);
// Acquire a scoped read-only lock to the workspace (prevent segfault from
// algos modifying ws)
Mantid::Kernel::ReadLock lock(*imdws);
const size_t nDims = imdws->getNumDims();
size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
/*
Write mask array with correct order for each internal dimension.
*/
auto masks = Mantid::Kernel::make_unique<bool[]>(nDims);
for (size_t i_dim = 0; i_dim < nDims; ++i_dim) {
bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
masks[i_dim] =
!bIntegrated; // TRUE for unmaksed, integrated dimensions are masked.
}
// Ensure destruction in any event.
boost::scoped_ptr<IMDIterator> it(
createIteratorWithNormalization(m_normalizationOption, imdws.get()));
// Create 2 points per box.
vtkNew<vtkPoints> points;
points->SetNumberOfPoints(it->getDataSize() * 2);
// One scalar per box
vtkNew<vtkFloatArray> signals;
signals->Allocate(it->getDataSize());
signals->SetName(vtkDataSetFactory::ScalarName.c_str());
signals->SetNumberOfComponents(1);
size_t nVertexes;
auto visualDataSet = vtkSmartPointer<vtkUnstructuredGrid>::New();
visualDataSet->Allocate(it->getDataSize());
vtkNew<vtkIdList> linePointList;
linePointList->SetNumberOfIds(2);
Mantid::API::CoordTransform const *transform = NULL;
if (m_useTransform) {
transform = imdws->getTransformToOriginal();
}
Mantid::coord_t out[1];
auto useBox = std::vector<bool>(it->getDataSize());
double progressFactor = 0.5 / double(it->getDataSize());
double progressOffset = 0.5;
size_t iBox = 0;
do {
progressUpdating.eventRaised(double(iBox) * progressFactor);
Mantid::signal_t signal_normalized = it->getNormalizedSignal();
if (std::isfinite(signal_normalized) &&
m_thresholdRange->inRange(signal_normalized)) {
useBox[iBox] = true;
signals->InsertNextValue(static_cast<float>(signal_normalized));
auto coords = std::unique_ptr<coord_t[]>(
it->getVertexesArray(nVertexes, nNonIntegrated, masks.get()));
// Iterate through all coordinates. Candidate for speed improvement.
for (size_t v = 0; v < nVertexes; ++v) {
coord_t *coord = coords.get() + v * 1;
size_t id = iBox * 2 + v;
if (m_useTransform) {
transform->apply(coord, out);
points->SetPoint(id, out[0], 0, 0);
} else {
points->SetPoint(id, coord[0], 0, 0);
}
}
} // valid number of vertexes returned
else {
useBox[iBox] = false;
}
++iBox;
} while (it->next());
for (size_t ii = 0; ii < it->getDataSize(); ++ii) {
progressUpdating.eventRaised((double(ii) * progressFactor) +
progressOffset);
if (useBox[ii] == true) {
vtkIdType pointIds = ii * 2;
linePointList->SetId(0, pointIds + 0); // xyx
linePointList->SetId(1, pointIds + 1); // dxyz
visualDataSet->InsertNextCell(VTK_LINE, linePointList.GetPointer());
} // valid number of vertexes returned
}
signals->Squeeze();
points->Squeeze();
visualDataSet->SetPoints(points.GetPointer());
visualDataSet->GetCellData()->SetScalars(signals.GetPointer());
visualDataSet->Squeeze();
// Hedge against empty data sets
if (visualDataSet->GetNumberOfPoints() <= 0) {
vtkNullUnstructuredGrid nullGrid;
visualDataSet = nullGrid.createNullData();
}
vtkSmartPointer<vtkDataSet> dataset = visualDataSet;
return dataset;
}
}
/* ************** Others ******************* */
unsigned int n0,numscalars,numverts,numfaces,count,facecount,nidx;
double pt[3];
int dims[2] = {1, 1},vert_field,face_field;
vtkPoints *pts;
vtkCellArray *polys;
vtkIdTypeArray *faces;
// Get hold of vertices and faces
// Vertices
pts = pipefinal->GetOutput()->GetPoints();
//pts = surf->GetPoints();
numverts = pts->GetNumberOfPoints();
out_verts = mxCreateDoubleMatrix(numverts,3,mxREAL);
out_vertsptr = mxGetPr(out_verts);
for(n0=0;n0<numverts;n0++)
{
pts->GetPoint(n0,pt);
out_vertsptr[n0] = pt[0];
out_vertsptr[numverts+n0] = pt[1];
out_vertsptr[2*numverts+n0] = pt[2];
}
// Faces
polys = pipefinal->GetOutput()->GetPolys();
//polys = surf->GetPolys();
faces = (vtkIdTypeArray*)polys->GetData();
void mitk::Mesh::ExecuteOperation(Operation* operation)
{
//adding only the operations, that aren't implemented by the pointset.
switch (operation->GetOperationType())
{
case OpNOTHING:
break;
case OpNEWCELL:
{
mitk::LineOperation *lineOp =
dynamic_cast<mitk::LineOperation *>(operation);
// if no lineoperation, then call superclass pointSet
if (lineOp == nullptr)
{
Superclass::ExecuteOperation(operation);
}
bool ok;
int cellId = lineOp->GetCellId();
CellAutoPointer cellAutoPointer;
ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
// if it doesn't already exist
if (!ok)
{
cellAutoPointer.TakeOwnership( new PolygonType );
m_PointSetSeries[0]->SetCell(cellId, cellAutoPointer);
CellDataType cellData;
cellData.selected = true;
cellData.selectedLines.clear();
cellData.closed = false;
m_PointSetSeries[0]->SetCellData(cellId, cellData);
}
}
break;
case OpDELETECELL:
{
mitk::LineOperation *lineOp = dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)//if no lineoperation, then call superclass pointSet
{
Superclass::ExecuteOperation(operation);
}
m_PointSetSeries[0]->GetCells()->DeleteIndex((unsigned)lineOp->GetCellId());
m_PointSetSeries[0]->GetCellData()->DeleteIndex((unsigned)lineOp->GetCellId());
}
break;
case OpCLOSECELL:
//sets the bolean flag closed from a specified cell to true.
{
mitk::LineOperation *lineOp = dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)//if no lineoperation, then call superclass pointSet
{
//then search the selected cell!//TODO
Superclass::ExecuteOperation(operation);
}
bool ok;
int cellId = lineOp->GetCellId();
if (cellId<0)//cellId isn't set
{
cellId = this->SearchSelectedCell( 0 );
if (cellId < 0 )//still not found
return;
}
CellAutoPointer cellAutoPointer;
//get directly the celldata!TODO
ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellDataType cellData;
m_PointSetSeries[0]->GetCellData(cellId, &cellData);
cellData.closed = true;
m_PointSetSeries[0]->SetCellData(cellId, cellData);
}
}
break;
case OpOPENCELL:
{
mitk::LineOperation *lineOp = dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)//if no lineoperation, then call superclass pointSet
{
Superclass::ExecuteOperation(operation);
}
bool ok;
int cellId = lineOp->GetCellId();
CellAutoPointer cellAutoPointer;
ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellDataType cellData;
m_PointSetSeries[0]->GetCellData(cellId, &cellData);
cellData.closed = false;;
m_PointSetSeries[0]->SetCellData(cellId, cellData);
}
}
break;
case OpADDLINE:
// inserts the ID of the selected point into the indexes of lines in the
// selected cell afterwars the added line is selected
{
mitk::LineOperation *lineOp =
dynamic_cast<mitk::LineOperation *>(operation);
int cellId = -1;
int pId = -1;
if (lineOp == nullptr)
{
cellId = this->SearchSelectedCell( 0 );
if (cellId == -1)
return;
pId = this->SearchSelectedPoint( 0 );
if (pId == -1)
return;
}
else
{
cellId = lineOp->GetCellId();
if (cellId == -1)
return;
pId = lineOp->GetPIdA();
if (pId == -1)
return;
}
bool ok;
CellAutoPointer cellAutoPointer;
ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellType * cell = cellAutoPointer.GetPointer();
if( cell->GetType() == CellType::POLYGON_CELL )
{
PolygonType * polygon = static_cast<PolygonType *>( cell );
// add the pointId to the Cell. filling the empty cell with
// one id doesn't mean to add a line, it means, that the
// initilal PointId is set. The next addition of a pointId adds
// a line
polygon->AddPointId(pId);
// select the line, if we really added a line, so now have more than
// 1 pointID in the cell
CellDataType cellData;
ok = m_PointSetSeries[0]->GetCellData(cellId, &cellData);
if (ok)
{
// A line between point 0 and 1 has the Id 0. A line between
// 1 and 2 has a Id = 1. So we add getnumberofpoints-2.
if (polygon->GetNumberOfPoints()>1)
cellData.selectedLines.push_back(polygon->GetNumberOfPoints()-2);
}
m_PointSetSeries[0]->SetCellData(cellId, cellData);
m_PointSetSeries[0]->SetCell(cellId, cellAutoPointer);
}
}
}
break;
case OpDELETELINE:
{
// deleted the last line through removing the index PIdA
// (if set to -1, use the last point) in the given cellId
mitk::LineOperation *lineOp = dynamic_cast<mitk::LineOperation *>(operation);
int cellId = -1;
int pId = -1;
if (lineOp == nullptr)
{
cellId = this->SearchSelectedCell( 0 );
if (cellId == -1)
return;
pId = this->SearchSelectedPoint( 0 );
}
else
{
cellId = lineOp->GetCellId();
if (cellId == -1)
return;
pId = lineOp->GetPIdA();
}
bool ok;
CellAutoPointer cellAutoPointer;
ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellType * cell = cellAutoPointer.GetPointer();
if( cell->GetType() == CellType::POLYGON_CELL )
{
PolygonType * oldPolygon = static_cast<PolygonType *>( cell );
auto newPolygonCell = new PolygonType;
CellAutoPointer newCell;
newCell.TakeOwnership( newPolygonCell );
PointIdConstIterator it, oldend;
oldend = oldPolygon->PointIdsEnd();
if(pId >= 0)
{
for(it = oldPolygon->PointIdsBegin(); it != oldend; ++it)
{
if((*it) != (MeshType::PointIdentifier)pId)
{
newPolygonCell->AddPointId(*it);
}
}
}
else
{
--oldend;
for(it = oldPolygon->PointIdsBegin(); it != oldend; ++it)
newPolygonCell->AddPointId(*it);
}
oldPolygon->SetPointIds(0, newPolygonCell->GetNumberOfPoints(),
newPolygonCell->PointIdsBegin());
}
}
}
break;
case OpREMOVELINE:
//Remove the given Index in the given cell through copying everything
// into a new cell accept the one that has to be deleted.
{
mitk::LineOperation *lineOp =
dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)//if no lineoperation, then call superclass pointSet
{
Superclass::ExecuteOperation(operation);
}
bool ok;
CellAutoPointer cellAutoPointer;
int cellId = lineOp->GetCellId();
ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (!ok)
return;
CellType * cell = cellAutoPointer.GetPointer();
CellAutoPointer newCellAutoPointer;
newCellAutoPointer.TakeOwnership( new PolygonType );
PolygonType * newPolygon = static_cast<PolygonType *>( cell );
PointIdIterator it = cell->PointIdsBegin();
PointIdIterator end = cell->PointIdsEnd();
int pointId = lineOp->GetPIdA();
if (pointId<0)//if not initialized!!
return;
while (it!=end)
{
if ((*it)==(unsigned int)pointId)
{
break;
}
else
{
newPolygon ->AddPointId(*it);
}
++it;
}
while (it!=end)
{
newPolygon ->AddPointId(*it);
it++;
}
m_PointSetSeries[0]->SetCell(cellId, newCellAutoPointer);
}
break;
case OpINSERTLINE:
// //insert line between two other points.
////before A--B after A--C--B
// //the points A, B and C have to be in the pointset.
// //needed: CellId, Id of C , Id A and Id B
////the cell has to exist!
//{
//mitk::LineOperation *lineOp = dynamic_cast<mitk::LineOperation *>(operation);
// if (lineOp == NULL)//if no lineoperation, then call superclass pointSet
// {
// Superclass::ExecuteOperation(operation);
// }
// int cellId = lineOp->GetCellId();
// int pIdC = lineOp->GetPIdC();
// int pIdA = lineOp->GetPIdA();
// int pIdB = lineOp->GetPIdB();
// //the points of the given PointIds have to exist in the PointSet
// bool ok;
// ok = m_PointSetSeries[0]->GetPoints()->IndexExists(pIdA);
// if (!ok)
// return;
// ok = m_PointSetSeries[0]->GetPoints()->IndexExists(pIdB);
// if (!ok)
// return;
// ok = m_PointSetSeries[0]->GetPoints()->IndexExists(pIdC);
// if (!ok)
// return;
// // so the points do exist. So now check, if there is already a cell
// // with the given Id
// DataType::CellAutoPointer cell;
// ok = m_PointSetSeries[0]->GetCell(cellId, cell);
// if (!ok)
// return;
// //pIdA and pIdB should exist in the cell
//
// PointIdIterator pit = cell->PointIdsBegin();
// PointIdIterator end = cell->PointIdsEnd();
//
// //now arrange the new Ids in the cell like desired; pIdC between
// // pIdA and pIdB
// unsigned int nuPoints = cell->GetNumberOfPoints();
// std::vector<unsigned int> newPoints;
// pit = cell->PointIdsBegin();
// end = cell->PointIdsEnd();
// int i = 0;
// while( pit != end )
// {
// if ((*pit) = pIdA)
// {
// //now we have found the place to add pIdC after
// newPoints[i] = (*pit);
// i++;
// newPoints[i] = pIdC;
// }
// else
// newPoints[i] = (*pit);
// pit++;
// }
// //now we have the Ids, that existed before combined with the new ones
// //so delete the old cell
// //doesn't seem to be necessary!
// //cell->ClearPoints();
// pit = cell->PointIdsBegin();
// cell->SetPointIds(pit);
//}
break;
case OpMOVELINE://(moves two points)
{
mitk::LineOperation *lineOp =
dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)
{
mitk::StatusBar::GetInstance()->DisplayText(
"Message from mitkMesh: Recieved wrong type of operation! See mitkMeshInteractor.cpp", 10000);
return;
}
//create two operations out of the one operation and call superclass
//through the transmitted pointIds get the koordinates of the points.
//then add the transmitted vestor to them
//create two operations and send them to superclass
Point3D pointA, pointB;
pointA.Fill(0.0);
pointB.Fill(0.0);
m_PointSetSeries[0]->GetPoint(lineOp->GetPIdA(), &pointA);
m_PointSetSeries[0]->GetPoint(lineOp->GetPIdB(), &pointB);
pointA[0] += lineOp->GetVector()[0];
pointA[1] += lineOp->GetVector()[1];
pointA[2] += lineOp->GetVector()[2];
pointB[0] += lineOp->GetVector()[0];
pointB[1] += lineOp->GetVector()[1];
pointB[2] += lineOp->GetVector()[2];
auto operationA =
new mitk::PointOperation(OpMOVE, pointA, lineOp->GetPIdA());
auto operationB =
new mitk::PointOperation(OpMOVE, pointB, lineOp->GetPIdB());
Superclass::ExecuteOperation(operationA);
Superclass::ExecuteOperation(operationB);
}
break;
case OpSELECTLINE://(select the given line)
{
mitk::LineOperation *lineOp =
dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)//if no lineoperation, then call superclass pointSet
{
Superclass::ExecuteOperation(operation);
}
int cellId = lineOp->GetCellId();
CellAutoPointer cellAutoPointer;
bool ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellDataType cellData;
m_PointSetSeries[0]->GetCellData(cellId, &cellData);
SelectedLinesType *selectedLines = &(cellData.selectedLines);
auto position = std::find(selectedLines->begin(),
selectedLines->end(), (unsigned int) lineOp->GetId());
if (position == selectedLines->end())//if not alsready selected
{
cellData.selectedLines.push_back(lineOp->GetId());
}
m_PointSetSeries[0]->SetCellData(lineOp->GetCellId(), cellData);
}
}
break;
case OpDESELECTLINE://(deselect the given line)
{
mitk::LineOperation *lineOp = dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)
{
Superclass::ExecuteOperation(operation);
}
int cellId = lineOp->GetCellId();
CellAutoPointer cellAutoPointer;
bool ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellDataType cellData;
m_PointSetSeries[0]->GetCellData(cellId, &cellData);
SelectedLinesType *selectedLines = &(cellData.selectedLines);
auto position = std::find(selectedLines->begin(),
selectedLines->end(), (unsigned int) lineOp->GetId());
if (position != selectedLines->end())//if found
{
selectedLines->erase(position);
}
m_PointSetSeries[0]->SetCellData(cellId, cellData);
}
}
break;
case OpSELECTCELL://(select the given cell)
{
mitk::LineOperation *lineOp =
dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)//if no lineoperation, then call superclass pointSet
{
Superclass::ExecuteOperation(operation);
}
int cellId = lineOp->GetCellId();
CellAutoPointer cellAutoPointer;
//directly get the data!//TODO
bool ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellDataType cellData;
m_PointSetSeries[0]->GetCellData(cellId, &cellData);
cellData.selected = true;
m_PointSetSeries[0]->SetCellData(cellId, cellData);
}
}
break;
case OpDESELECTCELL://(deselect the given cell)
{
mitk::LineOperation *lineOp = dynamic_cast<mitk::LineOperation *>(operation);
if (lineOp == nullptr)//if no lineoperation, then call superclass pointSet
{
Superclass::ExecuteOperation(operation);
}
int cellId = lineOp->GetCellId();
CellAutoPointer cellAutoPointer;
bool ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellDataType cellData;
m_PointSetSeries[0]->GetCellData(cellId, &cellData);
cellData.selected = false;
m_PointSetSeries[0]->SetCellData(cellId, cellData);
}
}
break;
case OpMOVECELL:
//moves all Points of one cell according to the given vector
{
mitk::CellOperation *lineOp = dynamic_cast<mitk::CellOperation *>(operation);
if (lineOp == nullptr)//if no celloperation, then call superclass pointSet
{
Superclass::ExecuteOperation(operation);
}
int cellId = lineOp->GetCellId();
Vector3D vector = lineOp->GetVector();
//get the cell
CellAutoPointer cellAutoPointer;
bool ok = m_PointSetSeries[0]->GetCell(cellId, cellAutoPointer);
if (!ok)
return;
CellDataType cellData;
m_PointSetSeries[0]->GetCellData(cellId, &cellData);
// iterate through the pointIds of the CellData and move those points in
// the pointset
PointIdIterator it = cellAutoPointer->PointIdsBegin();
PointIdIterator end = cellAutoPointer->PointIdsEnd();
while(it != end)
{
unsigned int position = (*it);
PointType point;
point.Fill(0);
m_PointSetSeries[0]->GetPoint(position, &point);
point = point + vector;
m_PointSetSeries[0]->SetPoint(position, point);
++it;
}
}
break;
default:
//if the operation couldn't be handled here, then send it to superclass
Superclass::ExecuteOperation(operation);
return;
}
//to tell the mappers, that the data is modifierd and has to be updated
this->Modified();
mitk::OperationEndEvent endevent(operation);
((const itk::Object*)this)->InvokeEvent(endevent);
// As discussed lately, don't mess with rendering from inside data structures
//*todo has to be done here, cause of update-pipeline not working yet
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
int PatchDeformPW::fnGetNumberOfPoints(INode *node)
{
return GetNumberOfPoints(node);
}
vtkErrorMacro(<<"No data to glyph!");
return 1;
}
pts = new vtkIdType[source->GetMaxCellSize()];
trans = vtkTransform::New();
matrix = vtkMatrix4x4::New();
inOrigNodes = pd->GetArray("avtOriginalNodeNumbers");
inOrigCells = pd->GetArray("avtOriginalCellNumbers");
//
// Allocate storage for output PolyData
//
sourcePts = source->GetPoints();
numSourcePts = sourcePts->GetNumberOfPoints();
numSourceCells = source->GetNumberOfCells();
newPts = vtkPoints::New();
newPts->Allocate(numDirs*numPts*numSourcePts);
// Setting up for calls to PolyData::InsertNextCell()
if ( (sourceCells=source->GetVerts())->GetNumberOfCells() > 0 )
{
cells = vtkCellArray::New();
cells->Allocate(numDirs*numPts*sourceCells->GetSize());
output->SetVerts(cells);
cells->Delete();
}
if ( (sourceCells=this->GetSource()->GetLines())->GetNumberOfCells() > 0 )
{
bool sm2ccConverter::addScalarField(ccPointCloud * cloud, const std::string& name, bool overwrite_if_exist/*=true*/)
{
assert(m_sm_cloud && cloud);
if (!m_sm_cloud || !cloud)
return false;
//get the field
PCLScalarField field = m_sm_cloud->fields.at(pcl::getFieldIndex(*m_sm_cloud, name));
//if this field already exist, simply delete it
int id = cloud->getScalarFieldIndexByName(name.c_str());
if (id >= 0)
{
if (overwrite_if_exist)
cloud->deleteScalarField(id);
else
return false;
}
size_t pointCount = GetNumberOfPoints(m_sm_cloud);
//create new scalar field
ccScalarField* cc_scalar_field = new ccScalarField(name.c_str());
if (!cc_scalar_field->reserve((unsigned)pointCount))
{
cc_scalar_field->release();
return false;
}
//get PCL field
PCLScalarField pclField = m_sm_cloud->fields.at(pcl::getFieldIndex(*m_sm_cloud, name));
//check if int or float
bool floatField = (pclField.datatype == PCLScalarField::FLOAT32 || pclField.datatype == PCLScalarField::FLOAT64);
//temporary change the name of the given field to something else -> S5c4laR should be a pretty uncommon name,
int field_index = pcl::getFieldIndex(*m_sm_cloud, name);
m_sm_cloud->fields[field_index].name = std::string("S5c4laR");
if (floatField)
{
pcl::PointCloud<FloatScalar>::Ptr pcl_scalar(new pcl::PointCloud<FloatScalar>);
FROM_PCL_CLOUD(*m_sm_cloud, *pcl_scalar);
for (size_t i = 0; i < pointCount; ++i)
{
ScalarType scalar = (ScalarType)pcl_scalar->points[i].S5c4laR;
cc_scalar_field->addElement(scalar);
}
}
else
{
pcl::PointCloud<IntScalar>::Ptr pcl_scalar(new pcl::PointCloud<IntScalar>);
FROM_PCL_CLOUD(*m_sm_cloud, *pcl_scalar);
for (size_t i = 0; i < pointCount; ++i)
{
ScalarType scalar = (ScalarType)pcl_scalar->points[i].S5c4laR;
cc_scalar_field->addElement(scalar);
}
}
cc_scalar_field->computeMinAndMax();
cloud->addScalarField(cc_scalar_field);
cloud->setCurrentDisplayedScalarField(0);
cloud->showSF(true);
//restore old name for the scalar field
m_sm_cloud->fields[field_index].name = name;
return true;
}
/**
Create the vtkStructuredGrid from the provided workspace
@param progressUpdating: Reporting object to pass progress information up the
stack.
@return fully constructed vtkDataSet.
*/
vtkSmartPointer<vtkDataSet>
vtkMDHistoLineFactory::create(ProgressAction &progressUpdating) const {
auto product =
tryDelegatingCreation<MDHistoWorkspace, 1>(m_workspace, progressUpdating);
if (product != nullptr) {
return product;
} else {
g_log.warning() << "Factory " << this->getFactoryTypeName()
<< " is being used. You are viewing data with less than "
"three dimensions in the VSI. \n";
Mantid::Kernel::ReadLock lock(*m_workspace);
const int nBinsX =
static_cast<int>(m_workspace->getXDimension()->getNBins());
const coord_t minX = m_workspace->getXDimension()->getMinimum();
coord_t incrementX = m_workspace->getXDimension()->getBinWidth();
const int imageSize = nBinsX;
vtkNew<vtkPoints> points;
points->Allocate(static_cast<int>(imageSize));
vtkNew<vtkFloatArray> signal;
signal->Allocate(imageSize);
signal->SetName(vtkDataSetFactory::ScalarName.c_str());
signal->SetNumberOfComponents(1);
UnstructuredPoint unstructPoint;
const int nPointsX = nBinsX;
Column column(nPointsX);
NullCoordTransform transform;
// Mantid::API::CoordTransform* transform =
// m_workspace->getTransformFromOriginal();
Mantid::coord_t in[3];
Mantid::coord_t out[3];
double progressFactor = 0.5 / double(nBinsX);
double progressOffset = 0.5;
// Loop through dimensions
for (int i = 0; i < nPointsX; i++) {
progressUpdating.eventRaised(progressFactor * double(i));
in[0] = minX +
static_cast<coord_t>(i) * incrementX; // Calculate increment in x;
float signalScalar =
static_cast<float>(m_workspace->getSignalNormalizedAt(i));
if (!std::isfinite(signalScalar)) {
// Flagged so that topological and scalar data is not applied.
unstructPoint.isSparse = true;
} else {
if (i < (nBinsX - 1)) {
signal->InsertNextValue(static_cast<float>(signalScalar));
}
unstructPoint.isSparse = false;
}
transform.apply(in, out);
unstructPoint.pointId = points->InsertNextPoint(out);
column[i] = unstructPoint;
}
points->Squeeze();
signal->Squeeze();
auto visualDataSet = vtkSmartPointer<vtkUnstructuredGrid>::New();
visualDataSet->Allocate(imageSize);
visualDataSet->SetPoints(points.GetPointer());
visualDataSet->GetCellData()->SetScalars(signal.GetPointer());
for (int i = 0; i < nBinsX - 1; i++) {
progressUpdating.eventRaised((progressFactor * double(i)) +
progressOffset);
// Only create topologies for those cells which are not sparse.
if (!column[i].isSparse) {
vtkLine *line = vtkLine::New();
line->GetPointIds()->SetId(0, column[i].pointId);
line->GetPointIds()->SetId(1, column[i + 1].pointId);
visualDataSet->InsertNextCell(VTK_LINE, line->GetPointIds());
}
}
visualDataSet->Squeeze();
// Hedge against empty data sets
if (visualDataSet->GetNumberOfPoints() <= 0) {
vtkNullUnstructuredGrid nullGrid;
visualDataSet = nullGrid.createNullData();
}
vtkSmartPointer<vtkDataSet> dataset = visualDataSet;
return dataset;
}
}
