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 CDialog_init::moveFemur()// old version , not used
{
int temp_Px;
temp_Px=m_Px.GetPos()-m_Px_local;
m_Px_local=m_Px.GetPos();
int temp_Py;
temp_Py=m_Py.GetPos()-m_Py_local;
m_Py_local=m_Py.GetPos();
int temp_Pz;
temp_Pz=m_Pz.GetPos()-m_Pz_local;
m_Pz_local=m_Pz.GetPos();
int temp_Rx;
temp_Rx=m_Rx.GetPos()-m_Rx_local;
m_Rx_local=m_Rx.GetPos();
int temp_Ry;
temp_Ry=m_Ry.GetPos()-m_Ry_local;
m_Ry_local=m_Ry.GetPos();
int temp_Rz;
temp_Rz=m_Rz.GetPos()-m_Rz_local;
m_Rz_local=m_Rz.GetPos();
translation->Translate(temp_Px,temp_Py,temp_Pz);
translation->RotateX(temp_Rx);
translation->RotateY(temp_Ry);
translation->RotateZ(temp_Rz);
transformFilter->SetTransform(translation);
transformFilter->Update();
renderWindow->GetInteractor()->Render();
renderWindow2->GetInteractor()->Render();
renderWindow3->GetInteractor()->Render();
}
bool
operator ()(PopulationSPtr pop)
{
++num_gens;
// bool return_val = metric(pop);
vtkIdType row_num = table->InsertNextBlankRow();
table->SetValue(row_num, 0, num_gens);
table->SetValue(row_num, 1, metric->getVal());
if (table->GetNumberOfRows() > 2)
{
// Start interactor
chart->ClearPlots();
vtkPlot *line = chart->AddPlot(vtkChart::LINE);
#if VTK_MAJOR_VERSION <= 5
line->SetInput(table, 0, 1);
#else
line->SetInputData(table, 0, 1);
#endif
line->SetColor(0, 255, 0, 255);
line->SetWidth(1.0);
// view->Render();
//Finally render the scene
view->GetRenderWindow()->SetMultiSamples(0);
view->GetInteractor()->Initialize();
view->GetInteractor()->Render();
}
// view->GetInteractor()->Initialize();
return true;
}
std::vector<std::string> GetColumsWithString( std::string colName, vtkSmartPointer<vtkTable> table ){
std::vector<std::string> retVect;
for( int i=0; i<table->GetNumberOfColumns(); ++i ){
std::string current_column;
current_column = table->GetColumnName(i);
if( current_column.find(colName.c_str()) != std::string::npos ){
retVect.push_back( current_column );
}
}
return retVect;
}
void FieldDataVisualizer::setActiveEdgeActor(vtkSmartPointer<vtkActor>& _edgeActor) {
//Edge vis
vtkSmartPointer<vtkExtractEdges> edgeExtractorTemp = vtkExtractEdges::New();
edgeExtractorTemp->SetInputData(warpFilter->GetUnstructuredGridOutput());
vtkSmartPointer<vtkPolyDataMapper> edgeMapperTemp = vtkPolyDataMapper::New();
edgeMapperTemp->SetInputConnection(edgeExtractorTemp->GetOutputPort());
_edgeActor->SetMapper(edgeMapperTemp);
_edgeActor->GetProperty()->SetColor(0., 0., 0.);
_edgeActor->GetProperty()->SetLineWidth(3);
edgeMapperTemp->ScalarVisibilityOff();
}
void write(data_set_type &data_set, double time, bool set_number = true, bool print = true)
{
m_writer->SetInput(data_set);
std::string file_name = m_data_path;
if(set_number) file_name += "_" + detail::file_number(m_file_counter++, 10);
file_name += ".";
file_name += m_writer->GetDefaultFileExtension();
m_writer->SetFileName(file_name.c_str());
if (print) std::cout << "Saving " << file_name << " ... ";
m_writer->WriteNextTime(time);
if (print) std::cout << "done." << std::endl;
}
VtkWriter(const std::string &data_path, bool write_binary = true) :
m_file_counter(0),
m_data_path(data_path),
m_writer(vtkSmartPointer<vtk_writer_type>::New()),
m_write_binary(write_binary)
{
vtksys::SystemTools::MakeDirectory(data_path.c_str());
if (m_write_binary)
m_writer->SetDataModeToBinary();
else
m_writer->SetDataModeToAscii();
}
void FieldDataVisualizer::setActiveHueLut(vtkSmartPointer<vtkLookupTable>& _hueLut) {
double scalarRange[2];
myHMeshToVtkUnstructuredGrid->getVtkUnstructuredGrid()->GetPointData()->GetScalars()->GetRange(scalarRange);
mySelectedMapper->UseLookupTableScalarRangeOn();
// Create a lookup table to share between the mapper and the scalarbar
_hueLut->SetTableRange(scalarRange[0], scalarRange[1]);
_hueLut->SetHueRange(0.667, 0.0);
_hueLut->SetValueRange(1, 1);
_hueLut->Build();
mySelectedMapper->SetLookupTable(_hueLut);
}
//Update the features in this table whose names match (sets doFeat)
void AssociativeFeatureCalculator::Append(vtkSmartPointer<vtkTable> table)
{
//Compute features:
ftk::NuclearAssociationRules *assoc;
if( inputs_set ){
assoc = new ftk::NuclearAssociationRules("",0,lab_im, inp_im);
assoc->AddAssociation( input_association->GetRuleName(), "", input_association->GetOutDistance(), input_association->GetInDistance(), input_association->IsUseWholeObject(), input_association->IsUseBackgroundSubtraction(), input_association->IsUseMultiLevelThresholding(), input_association->GetNumberOfThresholds(), input_association->GetNumberIncludedInForeground(), input_association->GetAssocType(), input_association->get_path() );
}
else{
assoc = new ftk::NuclearAssociationRules("",0);
assoc->ReadRulesFromXML(inFilename);
}
assoc->PrintSelf();
assoc->Compute();
//Init the table (headers):
for (int i=0; i < assoc->GetNumofAssocRules(); ++i)
{
vtkSmartPointer<vtkDoubleArray> column = vtkSmartPointer<vtkDoubleArray>::New();
column->SetName( (fPrefix+assoc->GetAssociationRules().at(i).GetRuleName()).c_str() );
column->SetNumberOfValues( table->GetNumberOfRows() );
table->AddColumn(column);
}
//Now update the table:
std::vector<unsigned short> labels = assoc->GetLabels();
float** vals = assoc->GetAssocFeaturesList();
//#pragma omp parallel for num_threads(4)
for (int i=0; i<(int)labels.size(); ++i)
{
unsigned short id = labels.at(i);
if(id == 0) continue;
int row = -1;
for(int r=0; r<table->GetNumberOfRows(); ++r)
{
if( table->GetValue(r,0) == id )
{
row = r;
break;
}
}
if(row == -1) continue;
for (int f=0; f<assoc->GetNumofAssocRules(); ++f)
{
table->SetValueByName(row,(fPrefix+assoc->GetAssociationRules().at(f).GetRuleName()).c_str(), vtkVariant(vals[f][i]));
}
}
delete assoc;
}
void cv::viz::vtkImageMatSource::copyGrayImage(const Mat &source, vtkSmartPointer<vtkImageData> output)
{
unsigned char* dptr = reinterpret_cast<unsigned char*>(output->GetScalarPointer());
size_t elem_step = output->GetIncrements()[1]/sizeof(unsigned char);
for (int y = 0; y < source.rows; ++y)
{
unsigned char* drow = dptr + elem_step * y;
const unsigned char *srow = source.ptr<unsigned char>(y);
for (int x = 0; x < source.cols; ++x)
drow[x] = *srow++;
}
}
void cv::viz::vtkImageMatSource::copyRGBAImage(const Mat &source, vtkSmartPointer<vtkImageData> output)
{
Vec4b* dptr = reinterpret_cast<Vec4b*>(output->GetScalarPointer());
size_t elem_step = output->GetIncrements()[1]/sizeof(Vec4b);
for (int y = 0; y < source.rows; ++y)
{
Vec4b* drow = dptr + elem_step * y;
const unsigned char *srow = source.ptr<unsigned char>(y);
for (int x = 0; x < source.cols; ++x, srow += source.channels())
drow[x] = Vec4b(srow[2], srow[1], srow[0], srow[3]);
}
}
vtkSmartPointer<vtkTable> AppendTables(vtkSmartPointer<vtkTable> table_initial,vtkSmartPointer<vtkTable> table_new )
{
/*!
* Adds on table to the end of another
*/
//!fill the table with values
unsigned int counter = 0;
for(vtkIdType r = 0; r < table_new->GetNumberOfRows() ; r++ )
{
table_initial->InsertNextRow(table_new->GetRow(r));
}
return table_initial;
}
template <typename PointT> void
pcl::visualization::PointCloudGeometryHandlerXYZ<PointT>::getGeometry (vtkSmartPointer<vtkPoints> &points) const
{
if (!capable_)
return;
if (!points)
points = vtkSmartPointer<vtkPoints>::New ();
points->SetDataTypeToFloat ();
vtkSmartPointer<vtkFloatArray> data = vtkSmartPointer<vtkFloatArray>::New ();
data->SetNumberOfComponents (3);
vtkIdType nr_points = cloud_->points.size ();
// Add all points
vtkIdType j = 0; // true point index
float* pts = static_cast<float*> (malloc (nr_points * 3 * sizeof (float)));
// If the dataset has no invalid values, just copy all of them
if (cloud_->is_dense)
{
for (vtkIdType i = 0; i < nr_points; ++i)
{
pts[i * 3 + 0] = cloud_->points[i].x;
pts[i * 3 + 1] = cloud_->points[i].y;
pts[i * 3 + 2] = cloud_->points[i].z;
}
data->SetArray (&pts[0], nr_points * 3, 0);
points->SetData (data);
}
// Need to check for NaNs, Infs, ec
else
{
for (vtkIdType i = 0; i < nr_points; ++i)
{
// Check if the point is invalid
if (!pcl_isfinite (cloud_->points[i].x) || !pcl_isfinite (cloud_->points[i].y) || !pcl_isfinite (cloud_->points[i].z))
continue;
pts[j * 3 + 0] = cloud_->points[i].x;
pts[j * 3 + 1] = cloud_->points[i].y;
pts[j * 3 + 2] = cloud_->points[i].z;
// Set j and increment
j++;
}
data->SetArray (&pts[0], j * 3, 0);
points->SetData (data);
}
}
void CDialog_init::rotRz()
{
int temp_Rz;
temp_Rz=m_Rz.GetPos()-m_Rz_local;
m_Rz_local=m_Rz.GetPos();
translation->RotateZ(temp_Rz);
transformFilter->SetTransform(translation);
transformFilter->Update();
renderWindow->GetInteractor()->Render();
GetDlgItem(IDC_STATIC_VIEW2)->RedrawWindow();
GetDlgItem(IDC_STATIC_VIEW3)->RedrawWindow();
// renderWindow2->GetInteractor()->Render();
// renderWindow3->GetInteractor()->Render();
}
void CDialog_subSTL::OnBnClickedButton4() //scaled
{
vtkSmartPointer<vtkQuadricDecimation> decimate = vtkSmartPointer<vtkQuadricDecimation>::New();//scale method in VTK
decimate->SetInputConnection(STLReader->GetOutputPort());
decimate->Update();
vtkSmartPointer<vtkPolyData> decimated = vtkSmartPointer<vtkPolyData>::New();
decimated->ShallowCopy(decimate->GetOutput());
vtkSmartPointer<vtkSTLWriter> stlWriter = vtkSmartPointer<vtkSTLWriter>::New();
stlWriter->SetFileName("test_saled.stl");
stlWriter->SetInput(decimated); //stlWriter->SetInput(map->GetOutput());
stlWriter->Write();
MessageBox(_T("Scaled Done"));
renderWindowInteractor_STL->GetRenderWindow()->Finalize(); // close renderwindow
renderWindowInteractor_STL->TerminateApp();
}
template <typename PointT> bool
pcl::visualization::PointCloudColorHandlerRandom<PointT>::getColor (vtkSmartPointer<vtkDataArray> &scalars) const
{
if (!capable_ || !cloud_)
return (false);
if (!scalars)
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
scalars->SetNumberOfComponents (3);
vtkIdType nr_points = cloud_->points.size ();
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetNumberOfTuples (nr_points);
// Get a random color
unsigned char* colors = new unsigned char[nr_points * 3];
double r, g, b;
pcl::visualization::getRandomColors (r, g, b);
int r_ = static_cast<int> (pcl_lrint (r * 255.0)),
g_ = static_cast<int> (pcl_lrint (g * 255.0)),
b_ = static_cast<int> (pcl_lrint (b * 255.0));
// Color every point
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
colors[cp * 3 + 0] = static_cast<unsigned char> (r_);
colors[cp * 3 + 1] = static_cast<unsigned char> (g_);
colors[cp * 3 + 2] = static_cast<unsigned char> (b_);
}
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetArray (colors, 3 * nr_points, 0, vtkUnsignedCharArray::VTK_DATA_ARRAY_DELETE);
return (true);
}
template <typename PointT> bool
pcl::visualization::PointCloudColorHandlerCustom<PointT>::getColor (vtkSmartPointer<vtkDataArray> &scalars) const
{
if (!capable_ || !cloud_)
return (false);
if (!scalars)
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
scalars->SetNumberOfComponents (3);
vtkIdType nr_points = cloud_->points.size ();
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetNumberOfTuples (nr_points);
// Get a random color
unsigned char* colors = new unsigned char[nr_points * 3];
// Color every point
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
colors[cp * 3 + 0] = static_cast<unsigned char> (r_);
colors[cp * 3 + 1] = static_cast<unsigned char> (g_);
colors[cp * 3 + 2] = static_cast<unsigned char> (b_);
}
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetArray (colors, 3 * nr_points, 0);
return (true);
}
void
getVoxelActors (pcl::PointCloud<pcl::PointXYZ>& voxelCenters,
double voxelSideLen, Eigen::Vector3f color,
vtkSmartPointer<vtkActorCollection> coll)
{
vtkSmartPointer < vtkAppendPolyData > treeWireframe = vtkSmartPointer<vtkAppendPolyData>::New ();
double s = voxelSideLen/2.0;
for (const auto &point : voxelCenters.points)
{
double x = point.x;
double y = point.y;
double z = point.z;
treeWireframe->AddInputData (getCuboid (x - s, x + s, y - s, y + s, z - s, z + s));
}
vtkSmartPointer < vtkLODActor > treeActor = vtkSmartPointer<vtkLODActor>::New ();
vtkSmartPointer < vtkDataSetMapper > mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
mapper->SetInputData (treeWireframe->GetOutput ());
treeActor->SetMapper (mapper);
treeActor->GetProperty ()->SetRepresentationToWireframe ();
treeActor->GetProperty ()->SetColor (color[0], color[1], color[2]);
treeActor->GetProperty ()->SetLineWidth (4);
coll->AddItem (treeActor);
}
template <typename PointT> void
pcl::visualization::PointCloudColorHandlerRandom<PointT>::getColor (vtkSmartPointer<vtkDataArray> &scalars) const
{
if (!capable_)
return;
if (!scalars)
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
scalars->SetNumberOfComponents (3);
vtkIdType nr_points = cloud_->points.size ();
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetNumberOfTuples (nr_points);
// Get a random color
unsigned char* colors = new unsigned char[nr_points * 3];
double r, g, b;
pcl::visualization::getRandomColors (r, g, b);
int r_ = pcl_lrint (r * 255.0), g_ = pcl_lrint (g * 255.0), b_ = pcl_lrint (b * 255.0);
// Color every point
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
colors[cp * 3 + 0] = r_;
colors[cp * 3 + 1] = g_;
colors[cp * 3 + 2] = b_;
}
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetArray (colors, 3 * nr_points, 0);
}
bool
pcl::visualization::PointCloudColorHandlerRandom<pcl::PCLPointCloud2>::getColor (vtkSmartPointer<vtkDataArray> &scalars) const
{
if (!capable_ || !cloud_)
return (false);
if (!scalars)
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
scalars->SetNumberOfComponents (3);
vtkIdType nr_points = cloud_->width * cloud_->height;
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetNumberOfTuples (nr_points);
// Get a random color
unsigned char* colors = new unsigned char[nr_points * 3];
double r, g, b;
pcl::visualization::getRandomColors (r, g, b);
long r_ = pcl_lrint (r * 255.0), g_ = pcl_lrint (g * 255.0), b_ = pcl_lrint (b * 255.0);
// Color every point
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
colors[cp * 3 + 0] = static_cast<unsigned char> (r_);
colors[cp * 3 + 1] = static_cast<unsigned char> (g_);
colors[cp * 3 + 2] = static_cast<unsigned char> (b_);
}
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetArray (colors, 3 * nr_points, 0);
return (true);
}
///
/// Given a buffer of scalar values, compute a histogram
/// using VTK
///
vtkSmartPointer<vtkImageAccumulate>
RenderPanel::ComputeHistogram(vtkSmartPointer<vtkFloatArray> scalars,
int numScalars,
double range[2])
{
// Compute a histogram for the curvs values
vtkSmartPointer<vtkImageData> scalarData = vtkSmartPointer<vtkImageData>::New();
vtkSmartPointer<vtkImageImport> scalarImport = vtkSmartPointer<vtkImageImport>::New();
scalarImport->SetDataOrigin(0, 0, 0);
scalarImport->SetWholeExtent(0, numScalars - 1, 0, 0, 0, 0);
scalarImport->SetDataExtentToWholeExtent();
scalarImport->SetDataScalarTypeToFloat();
scalarImport->SetNumberOfScalarComponents(1);
scalarImport->SetImportVoidPointer(scalars->GetPointer(0));
vtkSmartPointer<vtkImageExtractComponents> extract = vtkSmartPointer<vtkImageExtractComponents>::New();
extract->SetInputConnection( scalarImport->GetOutputPort() );
extract->SetComponents( 0 );
extract->Update();
extract->GetOutput()->GetScalarRange(range);
vtkSmartPointer<vtkImageAccumulate> histogram = vtkSmartPointer<vtkImageAccumulate>::New();
histogram->SetInputConnection( extract->GetOutputPort() );
histogram->SetComponentExtent( 0, 1000, 0, 0, 0, 0 );
histogram->SetComponentOrigin( range[0],0,0 );
histogram->SetComponentSpacing( (range[1] - range[0]) / 1000.0f, 0, 0 );
histogram->Update();
return histogram;
}
/** \brief Obtain the actual color for the input dataset as vtk scalars.
* \param[out] scalars the output scalars containing the color for the dataset
* \return true if the operation was successful (the handler is capable and
* the input cloud was given as a valid pointer), false otherwise
*/
virtual bool
getColor (vtkSmartPointer<vtkDataArray> &scalars) const
{
if (!capable_ || !cloud_)
return (false);
if (!scalars)
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
scalars->SetNumberOfComponents (3);
vtkIdType nr_points = vtkIdType (cloud_->points.size ());
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetNumberOfTuples (nr_points);
unsigned char* colors = reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->GetPointer (0);
// Color every point
if (nr_points != int (rgb_->points.size ()))
std::fill (colors, colors + nr_points * 3, static_cast<unsigned char> (0xFF));
else
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
int idx = cp * 3;
colors[idx + 0] = rgb_->points[cp].r;
colors[idx + 1] = rgb_->points[cp].g;
colors[idx + 2] = rgb_->points[cp].b;
}
return (true);
}
void vmtkRenderer::Initialize(vtkSmartPointer<vtkRenderWindow> renw)
{
Renderer = vtkSmartPointer<vtkRenderer>::New();
RenderWindow = renw;
double *color =new double[3];
color[0] = 0.0;
color[1] = 0.1;
color[2] = 0.3;
Renderer->SetBackground(color);
RenderWindowInteractor = renw->GetInteractor();
interactorCamera = vtkSmartPointer<vtkvmtkInteractorStyleTrackballCamera>::New();
//ÄܸıäÑÕÉ«
//Renderer->SetBackground();
RenderWindow->AddRenderer(Renderer);
//RenderWindow->SetSize();
//RenderWindow->SetPointSmoothing();
//RenderWindow->SetLineSmoothing();
//RenderWindow->SetPolygonSmoothing();
//renw->SetSize(800,600);
RenderWindowInteractor->SetInteractorStyle(interactorCamera);
//RenderWindowInteractor->SetRenderWindow(renw);
}
void NonRigid::setUserTrans(vtkSmartPointer<vtkMatrix4x4> mat)
{
if (!temp_mesh_vec.empty())
{
// convert vertices to eigen 4*n matrix
Eigen::MatrixXd v_mat(4, temp_mesh_vec.size()/3);
v_mat << Eigen::Map<Eigen::MatrixXd>(&temp_mesh_vec[0], 3, temp_mesh_vec.size()/3), Eigen::RowVectorXd::Ones(temp_mesh_vec.size()/3);
// set transform
Eigen::Matrix4d trans_mat;
for (size_t i = 0; i < 4; ++i)
{
for (size_t j = 0; j < 4; ++j)
{
trans_mat(i, j) = mat->GetElement(i, j);
}
}
Eigen::MatrixXd new_v_mat = trans_mat * v_mat;
temp_mesh_vec.clear();
for (size_t i = 0; i < new_v_mat.cols(); ++i)
{
temp_mesh_vec.push_back(new_v_mat(0, i)/new_v_mat(3, i));
temp_mesh_vec.push_back(new_v_mat(1, i)/new_v_mat(3, i));
temp_mesh_vec.push_back(new_v_mat(2, i)/new_v_mat(3, i));
}
}
}
void vtk_draw_view2(vtkSmartPointer<vtkRenderWindow> renderWindow,vtkSmartPointer<vtkRenderWindowInteractor> interactor)
{
vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
renderWindow->AddRenderer(renderer);
Renderers[1]=renderer;
//renderer->RemoveLight( renderer->GetLights()->GetNextItem());
vtkSmartPointer<vtkLight> light = vtkSmartPointer<vtkLight>::New();
light->SetLightTypeToSceneLight();
light->SetPosition(100, 100, 100);
light->SetFocalPoint(-100,-100,-100);
light->SetColor(0.5,0.5,0);
light->SetPositional(true); // required for vtkLightActor below
renderer->AddLight(light);
renderer->UpdateLightsGeometryToFollowCamera();
light->SetSwitch(false);
// light->SetConeAngle(10);
// light->SetFocalPoint(lightFocalPoint[0], lightFocalPoint[1], lightFocalPoint[2]);
// light->SetDiffuseColor(1,0,0);
// light->SetAmbientColor(0,1,0);
// light->SetSpecularColor(0,0,1);
renderer->SetBackground(0.1, 0.2, 0.4);
renderer->SetViewport(xmins[1],ymins[1],xmaxs[1],ymaxs[1]);
// m_source.m_display->draw_normal_points(renderer);
m_source.m_display->draw_triangle(renderer,interactor);
renderer->GetActiveCamera()->SetParallelProjection(1);
renderer->ResetCamera();
// renderWindow->Render();
}
template <typename PointT> void
pcl::visualization::PointCloudColorHandlerRGBCloud<PointT>::getColor (vtkSmartPointer<vtkDataArray> &scalars) const
{
if (!capable_)
return;
if (!scalars)
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
scalars->SetNumberOfComponents (3);
vtkIdType nr_points = vtkIdType (cloud_->points.size ());
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetNumberOfTuples (nr_points);
unsigned char* colors = reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->GetPointer (0);
// Color every point
if (nr_points != int (rgb_->points.size ()))
std::fill (colors, colors + nr_points * 3, static_cast<unsigned char> (0xFF));
else
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
int idx = cp * 3;
colors[idx + 0] = rgb_->points[cp].r;
colors[idx + 1] = rgb_->points[cp].g;
colors[idx + 2] = rgb_->points[cp].b;
}
}
template <typename PointT> bool
pcl::visualization::PointCloudColorHandlerGenericField<PointT>::getColor (vtkSmartPointer<vtkDataArray> &scalars) const
{
if (!capable_ || !cloud_)
return (false);
if (!scalars)
scalars = vtkSmartPointer<vtkFloatArray>::New ();
scalars->SetNumberOfComponents (1);
vtkIdType nr_points = cloud_->points.size ();
reinterpret_cast<vtkFloatArray*>(&(*scalars))->SetNumberOfTuples (nr_points);
typedef typename pcl::traits::fieldList<PointT>::type FieldList;
float* colors = new float[nr_points];
float field_data;
int j = 0;
// If XYZ present, check if the points are invalid
int x_idx = -1;
for (size_t d = 0; d < fields_.size (); ++d)
if (fields_[d].name == "x")
x_idx = static_cast<int> (d);
if (x_idx != -1)
{
// Color every point
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
// Copy the value at the specified field
if (!pcl_isfinite (cloud_->points[cp].x) || !pcl_isfinite (cloud_->points[cp].y) || !pcl_isfinite (cloud_->points[cp].z))
continue;
const uint8_t* pt_data = reinterpret_cast<const uint8_t*> (&cloud_->points[cp]);
memcpy (&field_data, pt_data + fields_[field_idx_].offset, pcl::getFieldSize (fields_[field_idx_].datatype));
colors[j] = field_data;
j++;
}
}
else
{
// Color every point
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
const uint8_t* pt_data = reinterpret_cast<const uint8_t*> (&cloud_->points[cp]);
memcpy (&field_data, pt_data + fields_[field_idx_].offset, pcl::getFieldSize (fields_[field_idx_].datatype));
if (!pcl_isfinite (field_data))
continue;
colors[j] = field_data;
j++;
}
}
reinterpret_cast<vtkFloatArray*>(&(*scalars))->SetArray (colors, j, 0, vtkFloatArray::VTK_DATA_ARRAY_DELETE);
return (true);
}
//----------------------------------------------------------------------------------------------------
unique_ptr<carve::mesh::MeshSet<3> > CarveConnector::vtkPolyDataToMeshSet(vtkSmartPointer<vtkPolyData> &thepolydata)
{
// First make MeshSet's points
vector<carve::geom3d::Vector> vertices;
vertices.resize(thepolydata->GetNumberOfPoints());
for (vtkIdType i = 0; i < thepolydata->GetNumberOfPoints(); i++)
{
double p[3];
thepolydata->GetPoint(i, p);
vertices[i] = carve::geom::VECTOR(p[0], p[1], p[2]);
}
// Then make MeshSet Faces
vtkSmartPointer<vtkCellArray> polys = thepolydata->GetPolys();
polys->InitTraversal();
vector<int> f;
int numfaces = 0;
int t = 0;
f.resize(polys->GetSize()); // exact size: n1, id1, id2, id3, n2, id1, id2..etc
for (int i = 0; i < polys->GetNumberOfCells(); i++)
{
vtkIdType n_pts;
vtkIdType *pts = nullptr;
polys->GetNextCell(n_pts, pts);
f[t++] = n_pts;
for (int j = 0; j < n_pts; j++)
f[t++] = pts[j];
//f[t++] = pts[0];
//f[t++] = pts[1];
//f[t++] = pts[2];
//if (n_pts > 3)
//f[t++] = pts[3];
numfaces++;
}
// Construct MeshSet from vertices and faces
unique_ptr<MeshSet<3> > first(new MeshSet<3>(vertices, numfaces, f));
return first;
}
cv::Matx44f cv::viz::convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
{
cv::Matx44f m;
for (int i = 0; i < 4; i++)
for (int k = 0; k < 4; k++)
m(i, k) = vtk_matrix->GetElement(i, k);
return m;
}
void SelectionUtilities::RemoveRowAndReMapTable(vtkIdType key, vtkSmartPointer<vtkTable> modTable, std::map< vtkIdType, vtkIdType> TableIDMap)
{
/*!
* remove a row from table
* rebuild map
*/
std::map< vtkIdType, vtkIdType>::iterator TableIDIter = TableIDMap.find(key);
if (TableIDIter != TableIDMap.end())
{
modTable->RemoveRow((*TableIDIter).second);
}
for (vtkIdType row = 0; row != modTable->GetNumberOfRows(); row++)
{
vtkIdType value = modTable->GetValue(row,0).ToTypeInt64();
TableIDMap[value] = row;
}
}