mitk::Mesh::DataType::BoundingBoxPointer
mitk::Mesh::GetBoundingBoxFromCell( unsigned long cellId, int t )
{
// itk::CellInterface has also a GetBoundingBox, but it
// returns CoordRepType [PointDimension *2]
DataType::BoundingBoxPointer bBoxPointer = nullptr;
CellAutoPointer cellAutoPointer;
if ( m_PointSetSeries[t]->GetCell(cellId, cellAutoPointer))
{
DataType::PointsContainerPointer pointsContainer = DataType::PointsContainer::New();
PointIdIterator bbIt = cellAutoPointer.GetPointer()->PointIdsBegin();
PointIdIterator bbEnd = cellAutoPointer.GetPointer()->PointIdsEnd();
while(bbIt != bbEnd)
{
mitk::PointSet::PointType point;
bool pointOk = m_PointSetSeries[t]->GetPoint((*bbIt), &point);
if (pointOk)
pointsContainer->SetElement((*bbIt), point);
++bbIt;
}
bBoxPointer = DataType::BoundingBoxType::New();
bBoxPointer->SetPoints(pointsContainer);
bBoxPointer->ComputeBoundingBox();
}
return bBoxPointer;
}
// get the cell; then iterate through the Ids times lineId. Then IdA ist the
// one, IdB ist ne next.don't forget the last closing line if the cell is
// closed
bool mitk::Mesh::GetPointIds( unsigned long cellId, unsigned long lineId,
int &idA, int &idB, int t )
{
bool ok = false;
bool found = false;
CellAutoPointer cellAutoPointer;
ok = m_PointSetSeries[t]->GetCell(cellId, cellAutoPointer);
if (ok)
{
CellType * cell = cellAutoPointer.GetPointer();
//Get the cellData to also check the closing line
CellDataType cellData;
m_PointSetSeries[t]->GetCellData(cellId, &cellData);
bool closed = cellData.closed;
PointIdIterator pointIdIt = cell->PointIdsBegin();
PointIdIterator pointIdEnd = cell->PointIdsEnd();
unsigned int counter = 0;
while (pointIdIt != pointIdEnd)
{
if(counter == lineId)
{
idA = (*pointIdIt);
++pointIdIt;
found = true;
break;
}
++counter;
++pointIdIt;
}
if(found)
{
//if in the middle
if (pointIdIt != pointIdEnd)
{
idB = (*pointIdIt);
}
// if found but on the end, then it is the closing connection, so the
// last and the first point
else if (closed)
{
pointIdIt = cell->PointIdsBegin();
idB = (*pointIdIt);
}
}
else
ok = false;
}
return ok;
}
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();
}
