Studio/Visualization/Viewer.h

Namespaces

Name
shapeworks User usage reporting (telemetry)

Classes

	Name
class	shapeworks::PickResult
class	shapeworks::Viewer 3D Viewer

Source code

```cpp

pragma once

include

class vtkRenderer; class vtkLookupTable; class vtkRenderWindowInteractor; class vtkImageData; class vtkCamera; class vtkGlyph3D; class vtkSphereSource; class vtkArrowSource; class vtkTransformPolyDataFilter; class vtkScalarBarActor; class vtkCornerAnnotation; class vtkPolyDataMapper; class vtkActor; class vtkTransform; class vtkReverseSense; class vtkHandleWidget; class vtkPolygonalSurfacePointPlacer; class vtkImageSlice; class vtkImageSliceMapper; class vtkImageData; class vtkCellPicker; class vtkPropPicker; class vtkColorSeries;

namespace shapeworks {

class Shape; class Viewer; class Visualizer; class StudioInteractorStyle; class LandmarkWidget; class PlaneWidget; class PaintWidget; class Session;

typedef QSharedPointer ViewerHandle; typedef QVector ViewerList;

class PickResult { public: Shape::Point pos_; int domain_ = -1; int subject_ = -1; };

class Viewer { public: Viewer(); ~Viewer() = default;

void set_renderer(vtkSmartPointer renderer); vtkSmartPointer get_renderer();

void display_shape(std::shared_ptr shape); void update_annotations();

void clear_viewer(); void reset_camera(std::array c); void reset_camera();

void set_color_series(ColorMap color_series); void set_glyph_size_and_quality(double size, double quality); double get_glyph_size(); double get_glyph_quality(); void set_session(QSharedPointer session); QSharedPointer get_session();

void set_show_glyphs(bool show); void set_show_surface(bool show); void set_scale_arrows(bool scale);

void update_points(); void update_glyph_properties();

int handle_pick(int* click_pos);

PickResult handle_ctrl_click(int* click_pos);

void set_selected_point(int id);

void set_glyph_lut(vtkSmartPointer lut);

void set_loading_screen(vtkSmartPointer loading_screen);

void set_color_scheme(int i);

void handle_new_mesh();

bool is_viewer_ready();

void set_visualizer(Visualizer* visualizer);

void update_feature_range(double* range); void reset_feature_range();

void update_opacities();

std::shared_ptr get_shape();

void update_landmarks(); void update_planes(); void update_paint_mode();

std::vector> get_surface_actors(); std::vector> get_unclipped_surface_actors();

MeshGroup get_meshes();

vtkSmartPointer get_transform(int alignment_domain, int domain);

vtkSmartPointer get_landmark_transform(int domain);

vtkSmartPointer get_inverse_landmark_transform(int domain);

vtkSmartPointer get_image_transform();

vtkSmartPointer get_inverse_image_transform();

SliceView& slice_view();

void update_image_volume(bool force = false);

vtkSmartPointer get_glyph_points();

vtkSmartPointer get_alignment_transform();

void update_clipping_planes();

vtkSmartPointer get_point_placer();

void handle_paint(double display_pos[2], double world_pos[3]);

void fill_all_ffc();

static bool is_reverse(vtkSmartPointer transform);

void update_actors();

void remove_scalar_bar();

bool is_ready() { return mesh_ready_; }

vtkFloatArray* get_particle_scalars();

vtkSmartPointer get_particle_poly_data();

void insert_compare_meshes();

void set_scalar_visibility(vtkSmartPointer poly_data, vtkSmartPointer mapper, std::string scalar);

vtkSmartPointer get_surface_lut() { return surface_lut_; }

bool showing_feature_map();

private: void initialize_surfaces();

void display_vector_field();

void compute_point_differences(const Eigen::VectorXd& points, vtkSmartPointer magnitudes, vtkSmartPointer vectors);

void compute_surface_differences(vtkSmartPointer magnitudes, vtkSmartPointer vectors);

void update_difference_lut(float r0, float r1);

std::string get_displayed_feature_map();

vtkSmartPointer transform_plane(vtkSmartPointer plane, vtkSmartPointer transform);

bool visible_ = false;

std::shared_ptr shape_;

bool show_glyphs_ = true; bool show_surface_ = true;

double glyph_size_ = 1.0f; double glyph_quality_ = 5.0f; bool scale_arrows_{true}; ColorMap color_series_;

vtkSmartPointer renderer_;

vtkSmartPointer sphere_source_; vtkSmartPointer reverse_sphere_;

vtkSmartPointer glyph_points_; vtkSmartPointer glyph_point_set_; vtkSmartPointer glyphs_; vtkSmartPointer glyph_mapper_; vtkSmartPointer glyph_actor_;

std::vector> surface_mappers_; std::vector> surface_actors_; std::vector> unclipped_surface_mappers_; std::vector> unclipped_surface_actors_; std::vector> ffc_luts_;

// for comparing to other shapes (e.g. original vs groomed) std::vector> compare_mappers_; std::vector> compare_actors_;

vtkSmartPointer glyph_lut_; vtkSmartPointer surface_lut_;

vtkSmartPointer arrow_source_; vtkSmartPointer arrow_flip_filter_; vtkSmartPointer arrow_glyphs_; vtkSmartPointer arrow_glyph_mapper_; vtkSmartPointer arrow_glyph_actor_; vtkSmartPointer transform_180_; vtkSmartPointer scalar_bar_actor_;

vtkSmartPointer corner_annotation_;

bool arrows_visible_ = false;

ColorSchemes color_schemes_; int scheme_ = 0;

bool mesh_ready_ = false; bool viewer_ready_ = false; bool loading_displayed_ = false;

MeshGroup meshes_; MeshGroup compare_meshes_;

Visualizer* visualizer_{nullptr};

int number_of_domains_ = 0; double lut_min_ = 0; double lut_max_ = 0;

std::shared_ptr landmark_widget_; std::shared_ptr plane_widget_; vtkSmartPointer paint_widget_;

QSharedPointer session_;

std::string current_image_name_ = "-none-";

vtkSmartPointer cell_picker_; vtkSmartPointer prop_picker_; vtkSmartPointer point_placer_; vtkSmartPointer slice_point_placer_;

// slice viewer SliceView slice_view_{this}; }; } // namespace shapeworks ```

Updated on 2026-03-31 at 16:02:11 +0000