DipsScripting 9.1.0__py3-none-any.whl

dips/Stereonet2DViewVal.py

@@ -0,0 +1,363 @@
+"""Generated wrapper for Stereonet2DView protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AnnotativeTools2DVal import AnnotativeTools2DVal
+from .FoldEntityVisibilityVal import FoldEntityVisibilityVal
+from .FoldWindowEntityVisibilityVal import FoldWindowEntityVisibilityVal
+from .KinematicAnalysisSettingsVal import KinematicAnalysisSettingsVal
+from .PlaneEntityVisibilityVal import PlaneEntityVisibilityVal
+from .QuantitativeContourSettingsVal import QuantitativeContourSettingsVal
+from .SetEntityVisibilityVal import SetEntityVisibilityVal
+from .SetWindowEntityVisibilityVal import SetWindowEntityVisibilityVal
+from .Stereonet2DPresetOptionsVal import Stereonet2DPresetOptionsVal
+from .StereonetProjectionModeVal import StereonetProjectionModeVal
+from .SymbolicSettingsVal import SymbolicSettingsVal
+from .TraverseEntityVisibilityVal import TraverseEntityVisibilityVal
+from .VectorDensityContourSettingsVal import VectorDensityContourSettingsVal
+from .DataFilterRef import DataFilterRef
+
+class Stereonet2DViewVal:
+    """Simple wrapper for Stereonet2DView with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.Stereonet2DView
+
+
+    def __init__(self, symbolic_settings: Optional[SymbolicSettingsVal] = None, pole_vector_density_contour_settings: Optional[VectorDensityContourSettingsVal] = None, intersection_vector_density_contour_settings: Optional[VectorDensityContourSettingsVal] = None, quantitative_contour_settings: Optional[QuantitativeContourSettingsVal] = None, kinematic_analysis_settings: Optional[KinematicAnalysisSettingsVal] = None, projection_mode: Optional[StereonetProjectionModeVal] = None, preset_options: Optional[Stereonet2DPresetOptionsVal] = None, annotative_tools: Optional[AnnotativeTools2DVal] = None, active_filter: Optional[DataFilterRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the Stereonet2DView wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if symbolic_settings is not None:
+            self._proto_message.SymbolicSettings.CopyFrom(symbolic_settings.to_proto())
+            self._symbolic_settings_wrapper = symbolic_settings
+        if pole_vector_density_contour_settings is not None:
+            self._proto_message.PoleVectorDensityContourSettings.CopyFrom(pole_vector_density_contour_settings.to_proto())
+            self._pole_vector_density_contour_settings_wrapper = pole_vector_density_contour_settings
+        if intersection_vector_density_contour_settings is not None:
+            self._proto_message.IntersectionVectorDensityContourSettings.CopyFrom(intersection_vector_density_contour_settings.to_proto())
+            self._intersection_vector_density_contour_settings_wrapper = intersection_vector_density_contour_settings
+        if quantitative_contour_settings is not None:
+            self._proto_message.QuantitativeContourSettings.CopyFrom(quantitative_contour_settings.to_proto())
+            self._quantitative_contour_settings_wrapper = quantitative_contour_settings
+        if kinematic_analysis_settings is not None:
+            self._proto_message.KinematicAnalysisSettings.CopyFrom(kinematic_analysis_settings.to_proto())
+            self._kinematic_analysis_settings_wrapper = kinematic_analysis_settings
+        if projection_mode is not None:
+            self._proto_message.ProjectionMode.CopyFrom(projection_mode.to_proto())
+            self._projection_mode_wrapper = projection_mode
+        if preset_options is not None:
+            self._proto_message.PresetOptions.CopyFrom(preset_options.to_proto())
+            self._preset_options_wrapper = preset_options
+        if annotative_tools is not None:
+            self._proto_message.AnnotativeTools.CopyFrom(annotative_tools.to_proto())
+            self._annotative_tools_wrapper = annotative_tools
+        if active_filter is not None:
+            self.active_filter = active_filter
+
+
+    # Properties
+
+    @property
+    def view_name(self) -> str:
+        """Get the ViewName field value."""
+        return self._proto_message.ViewName
+    
+    @view_name.setter
+    def view_name(self, value: str) -> None:
+        """Set the ViewName field value."""
+        self._proto_message.ViewName = value
+
+
+    @property
+    def is_weighted(self) -> bool:
+        """Get the IsWeighted field value."""
+        return self._proto_message.IsWeighted
+    
+    @is_weighted.setter
+    def is_weighted(self, value: bool) -> None:
+        """Set the IsWeighted field value."""
+        self._proto_message.IsWeighted = value
+
+
+    @property
+    def vector_mode(self) -> Any:
+        """Get the VectorMode field value."""
+        return self._proto_message.VectorMode
+    
+    @vector_mode.setter
+    def vector_mode(self, value: Any) -> None:
+        """Set the VectorMode field value."""
+        self._proto_message.VectorMode = value
+
+
+    @property
+    def symbolic_settings(self) -> SymbolicSettingsVal:
+        """Get the SymbolicSettings field as a wrapper."""
+        if not hasattr(self, '_symbolic_settings_wrapper'):
+            self._symbolic_settings_wrapper = SymbolicSettingsVal(proto_message=self._proto_message.SymbolicSettings)
+        return self._symbolic_settings_wrapper
+    
+    @symbolic_settings.setter
+    def symbolic_settings(self, value: SymbolicSettingsVal) -> None:
+        """Set the SymbolicSettings field to a wrapper."""
+        self._proto_message.SymbolicSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_symbolic_settings_wrapper'):
+            self._symbolic_settings_wrapper._proto_message.CopyFrom(self._proto_message.SymbolicSettings)
+
+
+    @property
+    def pole_vector_density_contour_settings(self) -> VectorDensityContourSettingsVal:
+        """Get the PoleVectorDensityContourSettings field as a wrapper."""
+        if not hasattr(self, '_pole_vector_density_contour_settings_wrapper'):
+            self._pole_vector_density_contour_settings_wrapper = VectorDensityContourSettingsVal(proto_message=self._proto_message.PoleVectorDensityContourSettings)
+        return self._pole_vector_density_contour_settings_wrapper
+    
+    @pole_vector_density_contour_settings.setter
+    def pole_vector_density_contour_settings(self, value: VectorDensityContourSettingsVal) -> None:
+        """Set the PoleVectorDensityContourSettings field to a wrapper."""
+        self._proto_message.PoleVectorDensityContourSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_pole_vector_density_contour_settings_wrapper'):
+            self._pole_vector_density_contour_settings_wrapper._proto_message.CopyFrom(self._proto_message.PoleVectorDensityContourSettings)
+
+
+    @property
+    def intersection_vector_density_contour_settings(self) -> VectorDensityContourSettingsVal:
+        """Get the IntersectionVectorDensityContourSettings field as a wrapper."""
+        if not hasattr(self, '_intersection_vector_density_contour_settings_wrapper'):
+            self._intersection_vector_density_contour_settings_wrapper = VectorDensityContourSettingsVal(proto_message=self._proto_message.IntersectionVectorDensityContourSettings)
+        return self._intersection_vector_density_contour_settings_wrapper
+    
+    @intersection_vector_density_contour_settings.setter
+    def intersection_vector_density_contour_settings(self, value: VectorDensityContourSettingsVal) -> None:
+        """Set the IntersectionVectorDensityContourSettings field to a wrapper."""
+        self._proto_message.IntersectionVectorDensityContourSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_intersection_vector_density_contour_settings_wrapper'):
+            self._intersection_vector_density_contour_settings_wrapper._proto_message.CopyFrom(self._proto_message.IntersectionVectorDensityContourSettings)
+
+
+    @property
+    def quantitative_contour_settings(self) -> QuantitativeContourSettingsVal:
+        """Get the QuantitativeContourSettings field as a wrapper."""
+        if not hasattr(self, '_quantitative_contour_settings_wrapper'):
+            self._quantitative_contour_settings_wrapper = QuantitativeContourSettingsVal(proto_message=self._proto_message.QuantitativeContourSettings)
+        return self._quantitative_contour_settings_wrapper
+    
+    @quantitative_contour_settings.setter
+    def quantitative_contour_settings(self, value: QuantitativeContourSettingsVal) -> None:
+        """Set the QuantitativeContourSettings field to a wrapper."""
+        self._proto_message.QuantitativeContourSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_quantitative_contour_settings_wrapper'):
+            self._quantitative_contour_settings_wrapper._proto_message.CopyFrom(self._proto_message.QuantitativeContourSettings)
+
+
+    @property
+    def kinematic_analysis_settings(self) -> KinematicAnalysisSettingsVal:
+        """Get the KinematicAnalysisSettings field as a wrapper."""
+        if not hasattr(self, '_kinematic_analysis_settings_wrapper'):
+            self._kinematic_analysis_settings_wrapper = KinematicAnalysisSettingsVal(proto_message=self._proto_message.KinematicAnalysisSettings)
+        return self._kinematic_analysis_settings_wrapper
+    
+    @kinematic_analysis_settings.setter
+    def kinematic_analysis_settings(self, value: KinematicAnalysisSettingsVal) -> None:
+        """Set the KinematicAnalysisSettings field to a wrapper."""
+        self._proto_message.KinematicAnalysisSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_kinematic_analysis_settings_wrapper'):
+            self._kinematic_analysis_settings_wrapper._proto_message.CopyFrom(self._proto_message.KinematicAnalysisSettings)
+
+
+    @property
+    def projection_mode(self) -> StereonetProjectionModeVal:
+        """Get the ProjectionMode field as a wrapper."""
+        if not hasattr(self, '_projection_mode_wrapper'):
+            self._projection_mode_wrapper = StereonetProjectionModeVal(proto_message=self._proto_message.ProjectionMode)
+        return self._projection_mode_wrapper
+    
+    @projection_mode.setter
+    def projection_mode(self, value: StereonetProjectionModeVal) -> None:
+        """Set the ProjectionMode field to a wrapper."""
+        self._proto_message.ProjectionMode.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_projection_mode_wrapper'):
+            self._projection_mode_wrapper._proto_message.CopyFrom(self._proto_message.ProjectionMode)
+
+
+    @property
+    def preset_options(self) -> Stereonet2DPresetOptionsVal:
+        """Get the PresetOptions field as a wrapper."""
+        if not hasattr(self, '_preset_options_wrapper'):
+            self._preset_options_wrapper = Stereonet2DPresetOptionsVal(proto_message=self._proto_message.PresetOptions)
+        return self._preset_options_wrapper
+    
+    @preset_options.setter
+    def preset_options(self, value: Stereonet2DPresetOptionsVal) -> None:
+        """Set the PresetOptions field to a wrapper."""
+        self._proto_message.PresetOptions.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_preset_options_wrapper'):
+            self._preset_options_wrapper._proto_message.CopyFrom(self._proto_message.PresetOptions)
+
+
+    @property
+    def set_window_entity_visibilities(self) -> List[SetWindowEntityVisibilityVal]:
+        """Get the SetWindowEntityVisibilities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.SetWindowEntityVisibilities, SetWindowEntityVisibilityVal)
+    
+    @set_window_entity_visibilities.setter
+    def set_window_entity_visibilities(self, value: List[SetWindowEntityVisibilityVal]) -> None:
+        """Set the SetWindowEntityVisibilities field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.SetWindowEntityVisibilities[:] = []
+        for item in value:
+            self._proto_message.SetWindowEntityVisibilities.append(item.to_proto())
+
+
+    @property
+    def mean_set_plane_entity_visibilities(self) -> List[SetEntityVisibilityVal]:
+        """Get the MeanSetPlaneEntityVisibilities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.MeanSetPlaneEntityVisibilities, SetEntityVisibilityVal)
+    
+    @mean_set_plane_entity_visibilities.setter
+    def mean_set_plane_entity_visibilities(self, value: List[SetEntityVisibilityVal]) -> None:
+        """Set the MeanSetPlaneEntityVisibilities field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.MeanSetPlaneEntityVisibilities[:] = []
+        for item in value:
+            self._proto_message.MeanSetPlaneEntityVisibilities.append(item.to_proto())
+
+
+    @property
+    def user_plane_entity_visibilities(self) -> List[PlaneEntityVisibilityVal]:
+        """Get the UserPlaneEntityVisibilities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.UserPlaneEntityVisibilities, PlaneEntityVisibilityVal)
+    
+    @user_plane_entity_visibilities.setter
+    def user_plane_entity_visibilities(self, value: List[PlaneEntityVisibilityVal]) -> None:
+        """Set the UserPlaneEntityVisibilities field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.UserPlaneEntityVisibilities[:] = []
+        for item in value:
+            self._proto_message.UserPlaneEntityVisibilities.append(item.to_proto())
+
+
+    @property
+    def traverse_entity_visibilities(self) -> List[TraverseEntityVisibilityVal]:
+        """Get the TraverseEntityVisibilities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.TraverseEntityVisibilities, TraverseEntityVisibilityVal)
+    
+    @traverse_entity_visibilities.setter
+    def traverse_entity_visibilities(self, value: List[TraverseEntityVisibilityVal]) -> None:
+        """Set the TraverseEntityVisibilities field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.TraverseEntityVisibilities[:] = []
+        for item in value:
+            self._proto_message.TraverseEntityVisibilities.append(item.to_proto())
+
+
+    @property
+    def fold_window_entity_visibilities(self) -> List[FoldWindowEntityVisibilityVal]:
+        """Get the FoldWindowEntityVisibilities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.FoldWindowEntityVisibilities, FoldWindowEntityVisibilityVal)
+    
+    @fold_window_entity_visibilities.setter
+    def fold_window_entity_visibilities(self, value: List[FoldWindowEntityVisibilityVal]) -> None:
+        """Set the FoldWindowEntityVisibilities field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.FoldWindowEntityVisibilities[:] = []
+        for item in value:
+            self._proto_message.FoldWindowEntityVisibilities.append(item.to_proto())
+
+
+    @property
+    def fold_entity_visibilities(self) -> List[FoldEntityVisibilityVal]:
+        """Get the FoldEntityVisibilities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.FoldEntityVisibilities, FoldEntityVisibilityVal)
+    
+    @fold_entity_visibilities.setter
+    def fold_entity_visibilities(self, value: List[FoldEntityVisibilityVal]) -> None:
+        """Set the FoldEntityVisibilities field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.FoldEntityVisibilities[:] = []
+        for item in value:
+            self._proto_message.FoldEntityVisibilities.append(item.to_proto())
+
+
+    @property
+    def annotative_tools(self) -> AnnotativeTools2DVal:
+        """Get the AnnotativeTools field as a wrapper."""
+        if not hasattr(self, '_annotative_tools_wrapper'):
+            self._annotative_tools_wrapper = AnnotativeTools2DVal(proto_message=self._proto_message.AnnotativeTools)
+        return self._annotative_tools_wrapper
+    
+    @annotative_tools.setter
+    def annotative_tools(self, value: AnnotativeTools2DVal) -> None:
+        """Set the AnnotativeTools field to a wrapper."""
+        self._proto_message.AnnotativeTools.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_annotative_tools_wrapper'):
+            self._annotative_tools_wrapper._proto_message.CopyFrom(self._proto_message.AnnotativeTools)
+
+
+    @property
+    def active_filter(self) -> DataFilterRef:
+        """Get the ActiveFilter field as a reference."""
+        return DataFilterRef(self.__channelToConnectOn, self._proto_message.ActiveFilter)
+    
+    @active_filter.setter
+    def active_filter(self, value: DataFilterRef) -> None:
+        """Set the ActiveFilter field to a reference."""
+        self._proto_message.ActiveFilter.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/Stereonet3DPresetOptionsVal.py

@@ -0,0 +1,281 @@
+"""Generated wrapper for Stereonet3DPresetOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ContourEntityVisibilityVal import ContourEntityVisibilityVal
+from .GlobalPlaneEntityVisibilityVal import GlobalPlaneEntityVisibilityVal
+from .IntersectionEntityVisibilityVal import IntersectionEntityVisibilityVal
+from .PoleEntityVisibilityVal import PoleEntityVisibilityVal
+from .StereonetOverlayEntityVisibilityVal import StereonetOverlayEntityVisibilityVal
+
+class Stereonet3DPresetOptionsVal:
+    """Simple wrapper for Stereonet3DPresetOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.Stereonet3DPresetOptions
+
+
+    def __init__(self, pole_entity_visibility: Optional[PoleEntityVisibilityVal] = None, intersection_entity_visibility: Optional[IntersectionEntityVisibilityVal] = None, contour_entity_visibility: Optional[ContourEntityVisibilityVal] = None, global_mean_plane_entity_visibility: Optional[GlobalPlaneEntityVisibilityVal] = None, global_best_fit_plane_entity_visibility: Optional[GlobalPlaneEntityVisibilityVal] = None, stereonet_overlay_entity_visibility: Optional[StereonetOverlayEntityVisibilityVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the Stereonet3DPresetOptions wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if pole_entity_visibility is not None:
+            self._proto_message.PoleEntityVisibility.CopyFrom(pole_entity_visibility.to_proto())
+            self._pole_entity_visibility_wrapper = pole_entity_visibility
+        if intersection_entity_visibility is not None:
+            self._proto_message.IntersectionEntityVisibility.CopyFrom(intersection_entity_visibility.to_proto())
+            self._intersection_entity_visibility_wrapper = intersection_entity_visibility
+        if contour_entity_visibility is not None:
+            self._proto_message.ContourEntityVisibility.CopyFrom(contour_entity_visibility.to_proto())
+            self._contour_entity_visibility_wrapper = contour_entity_visibility
+        if global_mean_plane_entity_visibility is not None:
+            self._proto_message.GlobalMeanPlaneEntityVisibility.CopyFrom(global_mean_plane_entity_visibility.to_proto())
+            self._global_mean_plane_entity_visibility_wrapper = global_mean_plane_entity_visibility
+        if global_best_fit_plane_entity_visibility is not None:
+            self._proto_message.GlobalBestFitPlaneEntityVisibility.CopyFrom(global_best_fit_plane_entity_visibility.to_proto())
+            self._global_best_fit_plane_entity_visibility_wrapper = global_best_fit_plane_entity_visibility
+        if stereonet_overlay_entity_visibility is not None:
+            self._proto_message.StereonetOverlayEntityVisibility.CopyFrom(stereonet_overlay_entity_visibility.to_proto())
+            self._stereonet_overlay_entity_visibility_wrapper = stereonet_overlay_entity_visibility
+
+
+    # Properties
+
+    @property
+    def pole_entity_visibility(self) -> PoleEntityVisibilityVal:
+        """Get the PoleEntityVisibility field as a wrapper."""
+        if not hasattr(self, '_pole_entity_visibility_wrapper'):
+            self._pole_entity_visibility_wrapper = PoleEntityVisibilityVal(proto_message=self._proto_message.PoleEntityVisibility)
+        return self._pole_entity_visibility_wrapper
+    
+    @pole_entity_visibility.setter
+    def pole_entity_visibility(self, value: PoleEntityVisibilityVal) -> None:
+        """Set the PoleEntityVisibility field to a wrapper."""
+        self._proto_message.PoleEntityVisibility.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_pole_entity_visibility_wrapper'):
+            self._pole_entity_visibility_wrapper._proto_message.CopyFrom(self._proto_message.PoleEntityVisibility)
+
+
+    @property
+    def intersection_entity_visibility(self) -> IntersectionEntityVisibilityVal:
+        """Get the IntersectionEntityVisibility field as a wrapper."""
+        if not hasattr(self, '_intersection_entity_visibility_wrapper'):
+            self._intersection_entity_visibility_wrapper = IntersectionEntityVisibilityVal(proto_message=self._proto_message.IntersectionEntityVisibility)
+        return self._intersection_entity_visibility_wrapper
+    
+    @intersection_entity_visibility.setter
+    def intersection_entity_visibility(self, value: IntersectionEntityVisibilityVal) -> None:
+        """Set the IntersectionEntityVisibility field to a wrapper."""
+        self._proto_message.IntersectionEntityVisibility.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_intersection_entity_visibility_wrapper'):
+            self._intersection_entity_visibility_wrapper._proto_message.CopyFrom(self._proto_message.IntersectionEntityVisibility)
+
+
+    @property
+    def contour_entity_visibility(self) -> ContourEntityVisibilityVal:
+        """Get the ContourEntityVisibility field as a wrapper."""
+        if not hasattr(self, '_contour_entity_visibility_wrapper'):
+            self._contour_entity_visibility_wrapper = ContourEntityVisibilityVal(proto_message=self._proto_message.ContourEntityVisibility)
+        return self._contour_entity_visibility_wrapper
+    
+    @contour_entity_visibility.setter
+    def contour_entity_visibility(self, value: ContourEntityVisibilityVal) -> None:
+        """Set the ContourEntityVisibility field to a wrapper."""
+        self._proto_message.ContourEntityVisibility.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_contour_entity_visibility_wrapper'):
+            self._contour_entity_visibility_wrapper._proto_message.CopyFrom(self._proto_message.ContourEntityVisibility)
+
+
+    @property
+    def set_window_entity_group_visibility(self) -> bool:
+        """Get the SetWindowEntityGroupVisibility field value."""
+        return self._proto_message.SetWindowEntityGroupVisibility
+    
+    @set_window_entity_group_visibility.setter
+    def set_window_entity_group_visibility(self, value: bool) -> None:
+        """Set the SetWindowEntityGroupVisibility field value."""
+        self._proto_message.SetWindowEntityGroupVisibility = value
+
+
+    @property
+    def mean_set_plane_entity_group_visibility(self) -> bool:
+        """Get the MeanSetPlaneEntityGroupVisibility field value."""
+        return self._proto_message.MeanSetPlaneEntityGroupVisibility
+    
+    @mean_set_plane_entity_group_visibility.setter
+    def mean_set_plane_entity_group_visibility(self, value: bool) -> None:
+        """Set the MeanSetPlaneEntityGroupVisibility field value."""
+        self._proto_message.MeanSetPlaneEntityGroupVisibility = value
+
+
+    @property
+    def user_plane_entity_group_visibility(self) -> bool:
+        """Get the UserPlaneEntityGroupVisibility field value."""
+        return self._proto_message.UserPlaneEntityGroupVisibility
+    
+    @user_plane_entity_group_visibility.setter
+    def user_plane_entity_group_visibility(self, value: bool) -> None:
+        """Set the UserPlaneEntityGroupVisibility field value."""
+        self._proto_message.UserPlaneEntityGroupVisibility = value
+
+
+    @property
+    def traverse_entity_group_visibility(self) -> bool:
+        """Get the TraverseEntityGroupVisibility field value."""
+        return self._proto_message.TraverseEntityGroupVisibility
+    
+    @traverse_entity_group_visibility.setter
+    def traverse_entity_group_visibility(self, value: bool) -> None:
+        """Set the TraverseEntityGroupVisibility field value."""
+        self._proto_message.TraverseEntityGroupVisibility = value
+
+
+    @property
+    def fold_window_entity_group_visibility(self) -> bool:
+        """Get the FoldWindowEntityGroupVisibility field value."""
+        return self._proto_message.FoldWindowEntityGroupVisibility
+    
+    @fold_window_entity_group_visibility.setter
+    def fold_window_entity_group_visibility(self, value: bool) -> None:
+        """Set the FoldWindowEntityGroupVisibility field value."""
+        self._proto_message.FoldWindowEntityGroupVisibility = value
+
+
+    @property
+    def fold_entity_group_visibility(self) -> bool:
+        """Get the FoldEntityGroupVisibility field value."""
+        return self._proto_message.FoldEntityGroupVisibility
+    
+    @fold_entity_group_visibility.setter
+    def fold_entity_group_visibility(self, value: bool) -> None:
+        """Set the FoldEntityGroupVisibility field value."""
+        self._proto_message.FoldEntityGroupVisibility = value
+
+
+    @property
+    def global_mean_plane_entity_visibility(self) -> GlobalPlaneEntityVisibilityVal:
+        """Get the GlobalMeanPlaneEntityVisibility field as a wrapper."""
+        if not hasattr(self, '_global_mean_plane_entity_visibility_wrapper'):
+            self._global_mean_plane_entity_visibility_wrapper = GlobalPlaneEntityVisibilityVal(proto_message=self._proto_message.GlobalMeanPlaneEntityVisibility)
+        return self._global_mean_plane_entity_visibility_wrapper
+    
+    @global_mean_plane_entity_visibility.setter
+    def global_mean_plane_entity_visibility(self, value: GlobalPlaneEntityVisibilityVal) -> None:
+        """Set the GlobalMeanPlaneEntityVisibility field to a wrapper."""
+        self._proto_message.GlobalMeanPlaneEntityVisibility.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_global_mean_plane_entity_visibility_wrapper'):
+            self._global_mean_plane_entity_visibility_wrapper._proto_message.CopyFrom(self._proto_message.GlobalMeanPlaneEntityVisibility)
+
+
+    @property
+    def global_best_fit_plane_entity_visibility(self) -> GlobalPlaneEntityVisibilityVal:
+        """Get the GlobalBestFitPlaneEntityVisibility field as a wrapper."""
+        if not hasattr(self, '_global_best_fit_plane_entity_visibility_wrapper'):
+            self._global_best_fit_plane_entity_visibility_wrapper = GlobalPlaneEntityVisibilityVal(proto_message=self._proto_message.GlobalBestFitPlaneEntityVisibility)
+        return self._global_best_fit_plane_entity_visibility_wrapper
+    
+    @global_best_fit_plane_entity_visibility.setter
+    def global_best_fit_plane_entity_visibility(self, value: GlobalPlaneEntityVisibilityVal) -> None:
+        """Set the GlobalBestFitPlaneEntityVisibility field to a wrapper."""
+        self._proto_message.GlobalBestFitPlaneEntityVisibility.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_global_best_fit_plane_entity_visibility_wrapper'):
+            self._global_best_fit_plane_entity_visibility_wrapper._proto_message.CopyFrom(self._proto_message.GlobalBestFitPlaneEntityVisibility)
+
+
+    @property
+    def stereonet_overlay_entity_visibility(self) -> StereonetOverlayEntityVisibilityVal:
+        """Get the StereonetOverlayEntityVisibility field as a wrapper."""
+        if not hasattr(self, '_stereonet_overlay_entity_visibility_wrapper'):
+            self._stereonet_overlay_entity_visibility_wrapper = StereonetOverlayEntityVisibilityVal(proto_message=self._proto_message.StereonetOverlayEntityVisibility)
+        return self._stereonet_overlay_entity_visibility_wrapper
+    
+    @stereonet_overlay_entity_visibility.setter
+    def stereonet_overlay_entity_visibility(self, value: StereonetOverlayEntityVisibilityVal) -> None:
+        """Set the StereonetOverlayEntityVisibility field to a wrapper."""
+        self._proto_message.StereonetOverlayEntityVisibility.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_stereonet_overlay_entity_visibility_wrapper'):
+            self._stereonet_overlay_entity_visibility_wrapper._proto_message.CopyFrom(self._proto_message.StereonetOverlayEntityVisibility)
+
+
+    @property
+    def show_legend(self) -> bool:
+        """Get the ShowLegend field value."""
+        return self._proto_message.ShowLegend
+    
+    @show_legend.setter
+    def show_legend(self, value: bool) -> None:
+        """Set the ShowLegend field value."""
+        self._proto_message.ShowLegend = value
+
+
+    @property
+    def show_properties_legend(self) -> bool:
+        """Get the ShowPropertiesLegend field value."""
+        return self._proto_message.ShowPropertiesLegend
+    
+    @show_properties_legend.setter
+    def show_properties_legend(self, value: bool) -> None:
+        """Set the ShowPropertiesLegend field value."""
+        self._proto_message.ShowPropertiesLegend = value
+
+
+    @property
+    def show_contours_legend(self) -> bool:
+        """Get the ShowContoursLegend field value."""
+        return self._proto_message.ShowContoursLegend
+    
+    @show_contours_legend.setter
+    def show_contours_legend(self, value: bool) -> None:
+        """Set the ShowContoursLegend field value."""
+        self._proto_message.ShowContoursLegend = value
+
+
+    @property
+    def show_major_planes_legend(self) -> bool:
+        """Get the ShowMajorPlanesLegend field value."""
+        return self._proto_message.ShowMajorPlanesLegend
+    
+    @show_major_planes_legend.setter
+    def show_major_planes_legend(self, value: bool) -> None:
+        """Set the ShowMajorPlanesLegend field value."""
+        self._proto_message.ShowMajorPlanesLegend = value
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"