Rename RimIntersection to RimExtrudedCurveIntersection

ApplicationCode/ProjectDataModel/CMakeLists_files.cmake

@@ -88,7 +88,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurve.h
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurve.h
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogWbsCurve.h
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionHandle.h
-${CMAKE_CURRENT_LIST_DIR}/RimIntersection.h
+${CMAKE_CURRENT_LIST_DIR}/RimExtrudedCurveIntersection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionCollection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionResultDefinition.h
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionResultsDefinitionCollection.h
@@ -233,7 +233,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurve.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurve.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimWellLogWbsCurve.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionHandle.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimIntersection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimExtrudedCurveIntersection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionCollection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionResultDefinition.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimIntersectionResultsDefinitionCollection.cpp

ApplicationCode/ProjectDataModel/Rim2dIntersectionView.cpp

@@ -26,7 +26,7 @@
 #include "RimGeoMechCellColors.h"
 #include "RimGeoMechView.h"
 #include "RimGridView.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 #include "RimIntersectionResultDefinition.h"
 #include "RimRegularLegendConfig.h"
 #include "RimSimWellInView.h"
@@ -123,7 +123,7 @@ void Rim2dIntersectionView::setVisible( bool isVisible )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void Rim2dIntersectionView::setIntersection( RimIntersection* intersection )
+void Rim2dIntersectionView::setIntersection( RimExtrudedCurveIntersection* intersection )
 {
     CAF_ASSERT( intersection );
 
@@ -135,7 +135,7 @@ void Rim2dIntersectionView::setIntersection( RimIntersection* intersection )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimIntersection* Rim2dIntersectionView::intersection() const
+RimExtrudedCurveIntersection* Rim2dIntersectionView::intersection() const
 {
     return m_intersection();
 }
@@ -553,7 +553,7 @@ void Rim2dIntersectionView::onCreateDisplayModel()
     m_flatSimWellPipePartMgr = nullptr;
     m_flatWellHeadPartMgr    = nullptr;
 
-    if ( m_intersection->type() == RimIntersection::CS_SIMULATION_WELL && m_intersection->simulationWell() )
+    if ( m_intersection->type() == RimExtrudedCurveIntersection::CS_SIMULATION_WELL && m_intersection->simulationWell() )
     {
         RimEclipseView* eclipseView = nullptr;
         m_intersection->firstAncestorOrThisOfType( eclipseView );
@@ -566,7 +566,7 @@ void Rim2dIntersectionView::onCreateDisplayModel()
     }
 
     m_flatWellpathPartMgr = nullptr;
-    if ( m_intersection->type() == RimIntersection::CS_WELL_PATH && m_intersection->wellPath() )
+    if ( m_intersection->type() == RimExtrudedCurveIntersection::CS_WELL_PATH && m_intersection->wellPath() )
     {
         Rim3dView* settingsView = nullptr;
         m_intersection->firstAncestorOrThisOfType( settingsView );

ApplicationCode/ProjectDataModel/Rim2dIntersectionView.h

@@ -22,7 +22,7 @@
 #include "cafPdmProxyValueField.h"
 #include "cafPdmPtrField.h"
 
-class RimIntersection;
+class RimExtrudedCurveIntersection;
 class RimRegularLegendConfig;
 class RimTernaryLegendConfig;
 class RivSimWellPipesPartMgr;
@@ -49,8 +49,8 @@ public:
     ~Rim2dIntersectionView( void ) override;
 
     void             setVisible( bool isVisible );
-    void             setIntersection( RimIntersection* intersection );
-    RimIntersection* intersection() const;
+    void             setIntersection( RimExtrudedCurveIntersection* intersection );
+    RimExtrudedCurveIntersection* intersection() const;
 
     bool     isUsingFormationNames() const override;
     void     scheduleGeometryRegen( RivCellSetEnum geometryType ) override;
@@ -117,7 +117,7 @@ private:
     caf::PdmChildField<RimRegularLegendConfig*> m_legendConfig;
     caf::PdmChildField<RimTernaryLegendConfig*> m_ternaryLegendConfig;
 
-    caf::PdmPtrField<RimIntersection*> m_intersection;
+    caf::PdmPtrField<RimExtrudedCurveIntersection*> m_intersection;
 
     cvf::ref<RivIntersectionPartMgr> m_flatIntersectionPartMgr;
     cvf::ref<RivSimWellPipesPartMgr> m_flatSimWellPipePartMgr;

ApplicationCode/ProjectDataModel/Rim2dIntersectionViewCollection.cpp

@@ -20,7 +20,7 @@
 
 #include "Rim2dIntersectionView.h"
 #include "RimCase.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 
 CAF_PDM_SOURCE_INIT( Rim2dIntersectionViewCollection, "Intersection2dViewCollection" );
 
@@ -61,10 +61,10 @@ void Rim2dIntersectionViewCollection::syncFromExistingIntersections( bool doUpda
     RimCase* parentCase = nullptr;
     this->firstAncestorOrThisOfTypeAsserted( parentCase );
 
-    std::vector<RimIntersection*> allOrderedIntersectionsInCase;
+    std::vector<RimExtrudedCurveIntersection*> allOrderedIntersectionsInCase;
     parentCase->descendantsIncludingThisOfType( allOrderedIntersectionsInCase );
 
-    std::set<RimIntersection*> currentIntersections( allOrderedIntersectionsInCase.begin(),
+    std::set<RimExtrudedCurveIntersection*> currentIntersections( allOrderedIntersectionsInCase.begin(),
                                                      allOrderedIntersectionsInCase.end() );
 
     // Delete views without a valid intersection
@@ -83,7 +83,7 @@ void Rim2dIntersectionViewCollection::syncFromExistingIntersections( bool doUpda
 
     // Build map from intersection to view
 
-    std::map<RimIntersection*, Rim2dIntersectionView*> intersectionToViewMap;
+    std::map<RimExtrudedCurveIntersection*, Rim2dIntersectionView*> intersectionToViewMap;
     for ( Rim2dIntersectionView* iv : m_intersectionViews )
     {
         CVF_ASSERT( iv && iv->intersection() );
@@ -94,7 +94,7 @@ void Rim2dIntersectionViewCollection::syncFromExistingIntersections( bool doUpda
 
     // Insert the old views in correct order, and create new views as we go
 
-    for ( RimIntersection* intersection : allOrderedIntersectionsInCase )
+    for ( RimExtrudedCurveIntersection* intersection : allOrderedIntersectionsInCase )
     {
         auto it = intersectionToViewMap.find( intersection );
         if ( it == intersectionToViewMap.end() )

ApplicationCode/ProjectDataModel/RimCase.cpp

@@ -33,7 +33,7 @@
 #include "Rim2dIntersectionView.h"
 #include "Rim2dIntersectionViewCollection.h"
 #include "RimGridView.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 
 CAF_PDM_XML_ABSTRACT_SOURCE_INIT( RimCase, "RimCase" );
 

ApplicationCode/ProjectDataModel/RimCase.h

@@ -34,7 +34,7 @@ class RimGridView;
 class RimFormationNames;
 class RimTimeStepFilter;
 class Rim2dIntersectionView;
-class RimIntersection;
+class RimExtrudedCurveIntersection;
 class Rim2dIntersectionViewCollection;
 
 namespace cvf

ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp

@@ -74,7 +74,7 @@
 #include "RimGridCrossPlotCollection.h"
 #include "RimGridCrossPlotDataSet.h"
 #include "RimIdenticalGridCaseGroup.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 #include "RimIntersectionBox.h"
 #include "RimIntersectionCollection.h"
 #include "RimIntersectionResultDefinition.h"
@@ -666,7 +666,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
             menuBuilder.addSeparator();
             menuBuilder << "RicCopyIntersectionsToAllViewsInCaseFeature";
         }
-        else if ( dynamic_cast<RimIntersection*>( uiItem ) )
+        else if ( dynamic_cast<RimExtrudedCurveIntersection*>( uiItem ) )
         {
             menuBuilder << "RicPasteIntersectionsFeature";
             menuBuilder.addSeparator();

ApplicationCode/ProjectDataModel/RimEclipseView.cpp

@@ -59,7 +59,7 @@
 #include "RimGridCollection.h"
 #include "RimGridCrossPlotDataSet.h"
 #include "RimGridView.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 #include "RimIntersectionCollection.h"
 #include "RimIntersectionResultDefinition.h"
 #include "RimIntersectionResultsDefinitionCollection.h"
@@ -1633,7 +1633,7 @@ void RimEclipseView::calculateCompletionTypeAndRedrawIfRequired()
     {
         this->loadDataAndUpdate();
 
-        std::vector<RimIntersection*> intersections = m_crossSectionCollection->intersections();
+        std::vector<RimExtrudedCurveIntersection*> intersections = m_crossSectionCollection->intersections();
         for ( auto intersection : intersections )
         {
             if ( intersection && intersection->correspondingIntersectionView() )

ApplicationCode/ProjectDataModel/RimExtrudedCurveIntersection.cpp

@@ -17,7 +17,7 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 
 #include "RiaApplication.h"
 
@@ -55,32 +55,32 @@
 namespace caf
 {
 template <>
-void caf::AppEnum<RimIntersection::CrossSectionEnum>::setUp()
+void caf::AppEnum<RimExtrudedCurveIntersection::CrossSectionEnum>::setUp()
 {
-    addItem( RimIntersection::CS_WELL_PATH, "CS_WELL_PATH", "Well Path" );
-    addItem( RimIntersection::CS_SIMULATION_WELL, "CS_SIMULATION_WELL", "Simulation Well" );
-    addItem( RimIntersection::CS_POLYLINE, "CS_POLYLINE", "Polyline" );
-    addItem( RimIntersection::CS_AZIMUTHLINE, "CS_AZIMUTHLINE", "Azimuth and Dip" );
-    setDefault( RimIntersection::CS_WELL_PATH );
+    addItem( RimExtrudedCurveIntersection::CS_WELL_PATH, "CS_WELL_PATH", "Well Path" );
+    addItem( RimExtrudedCurveIntersection::CS_SIMULATION_WELL, "CS_SIMULATION_WELL", "Simulation Well" );
+    addItem( RimExtrudedCurveIntersection::CS_POLYLINE, "CS_POLYLINE", "Polyline" );
+    addItem( RimExtrudedCurveIntersection::CS_AZIMUTHLINE, "CS_AZIMUTHLINE", "Azimuth and Dip" );
+    setDefault( RimExtrudedCurveIntersection::CS_WELL_PATH );
 }
 
 template <>
-void caf::AppEnum<RimIntersection::CrossSectionDirEnum>::setUp()
+void caf::AppEnum<RimExtrudedCurveIntersection::CrossSectionDirEnum>::setUp()
 {
-    addItem( RimIntersection::CS_VERTICAL, "CS_VERTICAL", "Vertical" );
-    addItem( RimIntersection::CS_HORIZONTAL, "CS_HORIZONTAL", "Horizontal" );
-    addItem( RimIntersection::CS_TWO_POINTS, "CS_TWO_POINTS", "Defined by Two Points" );
-    setDefault( RimIntersection::CS_VERTICAL );
+    addItem( RimExtrudedCurveIntersection::CS_VERTICAL, "CS_VERTICAL", "Vertical" );
+    addItem( RimExtrudedCurveIntersection::CS_HORIZONTAL, "CS_HORIZONTAL", "Horizontal" );
+    addItem( RimExtrudedCurveIntersection::CS_TWO_POINTS, "CS_TWO_POINTS", "Defined by Two Points" );
+    setDefault( RimExtrudedCurveIntersection::CS_VERTICAL );
 }
 
 } // namespace caf
 
-CAF_PDM_SOURCE_INIT( RimIntersection, "CrossSection" );
+CAF_PDM_SOURCE_INIT( RimExtrudedCurveIntersection, "CrossSection" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimIntersection::RimIntersection()
+RimExtrudedCurveIntersection::RimExtrudedCurveIntersection()
 {
     CAF_PDM_InitObject( "Intersection", ":/CrossSection16x16.png", "", "" );
 
@@ -137,12 +137,12 @@ RimIntersection::RimIntersection()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimIntersection::~RimIntersection() {}
+RimExtrudedCurveIntersection::~RimExtrudedCurveIntersection() {}
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
+void RimExtrudedCurveIntersection::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
                                         const QVariant&            oldValue,
                                         const QVariant&            newValue )
 {
@@ -232,7 +232,7 @@ void RimIntersection::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+void RimExtrudedCurveIntersection::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     uiOrdering.add( &m_name );
     caf::PdmUiGroup* geometryGroup = uiOrdering.addNewGroup( "Intersecting Geometry" );
@@ -304,7 +304,7 @@ void RimIntersection::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QList<caf::PdmOptionItemInfo> RimIntersection::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
+QList<caf::PdmOptionItemInfo> RimExtrudedCurveIntersection::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
                                                                       bool*                      useOptionsOnly )
 {
     QList<caf::PdmOptionItemInfo> options;
@@ -361,7 +361,7 @@ QList<caf::PdmOptionItemInfo> RimIntersection::calculateValueOptions( const caf:
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimSimWellInViewCollection* RimIntersection::simulationWellCollection() const
+RimSimWellInViewCollection* RimExtrudedCurveIntersection::simulationWellCollection() const
 {
     RimEclipseView* eclipseView = nullptr;
     firstAncestorOrThisOfType( eclipseView );
@@ -377,7 +377,7 @@ RimSimWellInViewCollection* RimIntersection::simulationWellCollection() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::updateAzimuthLine()
+void RimExtrudedCurveIntersection::updateAzimuthLine()
 {
     if ( m_twoAzimuthPoints().size() == 2 )
     {
@@ -399,7 +399,7 @@ void RimIntersection::updateAzimuthLine()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::vector<cvf::Vec3d>> RimIntersection::polyLines( cvf::Vec3d* flattenedPolylineStartPoint ) const
+std::vector<std::vector<cvf::Vec3d>> RimExtrudedCurveIntersection::polyLines( cvf::Vec3d* flattenedPolylineStartPoint ) const
 {
     if ( flattenedPolylineStartPoint ) *flattenedPolylineStartPoint = cvf::Vec3d::ZERO;
 
@@ -492,7 +492,7 @@ std::vector<std::vector<cvf::Vec3d>> RimIntersection::polyLines( cvf::Vec3d* fla
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RivIntersectionPartMgr* RimIntersection::intersectionPartMgr()
+RivIntersectionPartMgr* RimExtrudedCurveIntersection::intersectionPartMgr()
 {
     if ( m_crossSectionPartMgr.isNull() ) m_crossSectionPartMgr = new RivIntersectionPartMgr( this );
 
@@ -502,7 +502,7 @@ RivIntersectionPartMgr* RimIntersection::intersectionPartMgr()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::rebuildGeometry()
+void RimExtrudedCurveIntersection::rebuildGeometry()
 {
     m_crossSectionPartMgr = nullptr;
 }
@@ -510,7 +510,7 @@ void RimIntersection::rebuildGeometry()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<cvf::Vec3d> RimIntersection::polyLinesForExtrusionDirection() const
+std::vector<cvf::Vec3d> RimExtrudedCurveIntersection::polyLinesForExtrusionDirection() const
 {
     return m_customExtrusionPoints;
 }
@@ -518,7 +518,7 @@ std::vector<cvf::Vec3d> RimIntersection::polyLinesForExtrusionDirection() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::updateSimulationWellCenterline() const
+void RimExtrudedCurveIntersection::updateSimulationWellCenterline() const
 {
     if ( m_isActive() && type == CS_SIMULATION_WELL && simulationWell() )
     {
@@ -540,7 +540,7 @@ void RimIntersection::updateSimulationWellCenterline() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::addExtents( std::vector<cvf::Vec3d>& polyLine ) const
+void RimExtrudedCurveIntersection::addExtents( std::vector<cvf::Vec3d>& polyLine ) const
 {
     size_t lineVxCount = polyLine.size();
 
@@ -596,7 +596,7 @@ void RimIntersection::addExtents( std::vector<cvf::Vec3d>& polyLine ) const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::updateWellExtentDefaultValue()
+void RimExtrudedCurveIntersection::updateWellExtentDefaultValue()
 {
     RimCase* ownerCase = nullptr;
     firstAncestorOrThisOfType( ownerCase );
@@ -614,7 +614,7 @@ void RimIntersection::updateWellExtentDefaultValue()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::updateName()
+void RimExtrudedCurveIntersection::updateName()
 {
     if ( type == CS_SIMULATION_WELL && simulationWell() )
     {
@@ -640,7 +640,7 @@ void RimIntersection::updateName()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-int RimIntersection::branchIndex() const
+int RimExtrudedCurveIntersection::branchIndex() const
 {
     RimSimWellInViewCollection* coll = simulationWellCollection();
 
@@ -660,7 +660,7 @@ int RimIntersection::branchIndex() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::setPushButtonText( bool buttonEnable, caf::PdmUiPushButtonEditorAttribute* attribute )
+void RimExtrudedCurveIntersection::setPushButtonText( bool buttonEnable, caf::PdmUiPushButtonEditorAttribute* attribute )
 {
     if ( attribute )
     {
@@ -678,7 +678,7 @@ void RimIntersection::setPushButtonText( bool buttonEnable, caf::PdmUiPushButton
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::setBaseColor( bool enable, caf::PdmUiListEditorAttribute* attribute )
+void RimExtrudedCurveIntersection::setBaseColor( bool enable, caf::PdmUiListEditorAttribute* attribute )
 {
     if ( attribute && enable )
     {
@@ -689,7 +689,7 @@ void RimIntersection::setBaseColor( bool enable, caf::PdmUiListEditorAttribute*
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::defineEditorAttribute( const caf::PdmFieldHandle* field,
+void RimExtrudedCurveIntersection::defineEditorAttribute( const caf::PdmFieldHandle* field,
                                              QString                    uiConfigName,
                                              caf::PdmUiEditorAttribute* attribute )
 {
@@ -742,7 +742,7 @@ void RimIntersection::defineEditorAttribute( const caf::PdmFieldHandle* field,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::appendPointToPolyLine( const cvf::Vec3d& point )
+void RimExtrudedCurveIntersection::appendPointToPolyLine( const cvf::Vec3d& point )
 {
     m_userPolyline.v().push_back( point );
 
@@ -754,7 +754,7 @@ void RimIntersection::appendPointToPolyLine( const cvf::Vec3d& point )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-Rim2dIntersectionView* RimIntersection::correspondingIntersectionView()
+Rim2dIntersectionView* RimExtrudedCurveIntersection::correspondingIntersectionView()
 {
     std::vector<Rim2dIntersectionView*> objects;
     this->objectsWithReferringPtrFieldsOfType( objects );
@@ -771,7 +771,7 @@ Rim2dIntersectionView* RimIntersection::correspondingIntersectionView()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::appendPointToExtrusionDirection( const cvf::Vec3d& point )
+void RimExtrudedCurveIntersection::appendPointToExtrusionDirection( const cvf::Vec3d& point )
 {
     if ( m_customExtrusionPoints().size() > 1 ) m_customExtrusionPoints.v().clear();
 
@@ -785,7 +785,7 @@ void RimIntersection::appendPointToExtrusionDirection( const cvf::Vec3d& point )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::appendPointToAzimuthLine( const cvf::Vec3d& point )
+void RimExtrudedCurveIntersection::appendPointToAzimuthLine( const cvf::Vec3d& point )
 {
     if ( m_twoAzimuthPoints().empty() )
     {
@@ -813,11 +813,11 @@ void RimIntersection::appendPointToAzimuthLine( const cvf::Vec3d& point )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-cvf::Vec3d RimIntersection::extrusionDirection() const
+cvf::Vec3d RimExtrudedCurveIntersection::extrusionDirection() const
 {
     cvf::Vec3d dir = cvf::Vec3d::Z_AXIS;
 
-    if ( direction() == RimIntersection::CS_HORIZONTAL )
+    if ( direction() == RimExtrudedCurveIntersection::CS_HORIZONTAL )
     {
         std::vector<std::vector<cvf::Vec3d>> lines = this->polyLines();
         if ( lines.size() > 0 && lines[0].size() > 1 )
@@ -832,7 +832,7 @@ cvf::Vec3d RimIntersection::extrusionDirection() const
             dir                    = polyLineDir ^ up;
         }
     }
-    else if ( direction() == RimIntersection::CS_TWO_POINTS && m_customExtrusionPoints().size() > 1 )
+    else if ( direction() == RimExtrudedCurveIntersection::CS_TWO_POINTS && m_customExtrusionPoints().size() > 1 )
     {
         dir = m_customExtrusionPoints()[m_customExtrusionPoints().size() - 1] - m_customExtrusionPoints()[0];
     }
@@ -854,7 +854,7 @@ cvf::Vec3d RimIntersection::extrusionDirection() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimIntersection::lengthUp() const
+double RimExtrudedCurveIntersection::lengthUp() const
 {
     return m_lengthUp;
 }
@@ -862,7 +862,7 @@ double RimIntersection::lengthUp() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimIntersection::lengthDown() const
+double RimExtrudedCurveIntersection::lengthDown() const
 {
     return m_lengthDown;
 }
@@ -870,7 +870,7 @@ double RimIntersection::lengthDown() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::setLengthDown( double lengthDown )
+void RimExtrudedCurveIntersection::setLengthDown( double lengthDown )
 {
     m_lengthDown = lengthDown;
 }
@@ -878,7 +878,7 @@ void RimIntersection::setLengthDown( double lengthDown )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimIntersection::extentLength()
+double RimExtrudedCurveIntersection::extentLength()
 {
     return m_extentLength();
 }
@@ -886,7 +886,7 @@ double RimIntersection::extentLength()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::recomputeSimulationWellBranchData()
+void RimExtrudedCurveIntersection::recomputeSimulationWellBranchData()
 {
     if ( type() == CS_SIMULATION_WELL )
     {
@@ -900,7 +900,7 @@ void RimIntersection::recomputeSimulationWellBranchData()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimIntersection::hasDefiningPoints() const
+bool RimExtrudedCurveIntersection::hasDefiningPoints() const
 {
     return type == CS_POLYLINE || type == CS_AZIMUTHLINE;
 }
@@ -908,7 +908,7 @@ bool RimIntersection::hasDefiningPoints() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::setLengthUp( double lengthUp )
+void RimExtrudedCurveIntersection::setLengthUp( double lengthUp )
 {
     m_lengthUp = lengthUp;
 }
@@ -916,7 +916,7 @@ void RimIntersection::setLengthUp( double lengthUp )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersection::rebuildGeometryAndScheduleCreateDisplayModel()
+void RimExtrudedCurveIntersection::rebuildGeometryAndScheduleCreateDisplayModel()
 {
     m_crossSectionPartMgr = nullptr;
 
@@ -938,7 +938,7 @@ void RimIntersection::rebuildGeometryAndScheduleCreateDisplayModel()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimIntersection::azimuthInRadians( cvf::Vec3d vec )
+double RimExtrudedCurveIntersection::azimuthInRadians( cvf::Vec3d vec )
 {
     return cvf::GeometryTools::getAngle( -cvf::Vec3d::Z_AXIS, cvf::Vec3d::Y_AXIS, vec );
 }

ApplicationCode/ProjectDataModel/RimExtrudedCurveIntersection.h

@@ -47,7 +47,7 @@ class PdmUiPushButtonEditorAttribute;
 //
 //
 //==================================================================================================
-class RimIntersection : public RimIntersectionHandle
+class RimExtrudedCurveIntersection : public RimIntersectionHandle
 {
     CAF_PDM_HEADER_INIT;
 
@@ -68,8 +68,8 @@ public:
     };
 
 public:
-    RimIntersection();
-    ~RimIntersection() override;
+    RimExtrudedCurveIntersection();
+    ~RimExtrudedCurveIntersection() override;
 
     caf::PdmField<caf::AppEnum<CrossSectionEnum>>    type;
     caf::PdmField<caf::AppEnum<CrossSectionDirEnum>> direction;

ApplicationCode/ProjectDataModel/RimIntersectionCollection.cpp

@@ -23,7 +23,7 @@
 #include "Rim2dIntersectionViewCollection.h"
 #include "Rim3dView.h"
 #include "RimCase.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 #include "RimIntersectionBox.h"
 #include "RimSimWellInView.h"
 
@@ -77,7 +77,7 @@ void RimIntersectionCollection::applySingleColorEffect()
 {
     if ( !this->isActive() ) return;
 
-    for ( RimIntersection* cs : m_intersections )
+    for ( RimExtrudedCurveIntersection* cs : m_intersections )
     {
         if ( cs->isActive() )
         {
@@ -101,7 +101,7 @@ void RimIntersectionCollection::updateCellResultColor( size_t timeStepIndex )
 {
     if ( !this->isActive() ) return;
 
-    for ( RimIntersection* cs : m_intersections )
+    for ( RimExtrudedCurveIntersection* cs : m_intersections )
     {
         if ( cs->isActive() )
         {
@@ -127,7 +127,7 @@ void RimIntersectionCollection::appendPartsToModel( Rim3dView&           view,
 {
     if ( !isActive() ) return;
 
-    for ( RimIntersection* cs : m_intersections )
+    for ( RimExtrudedCurveIntersection* cs : m_intersections )
     {
         if ( cs->isActive() )
         {
@@ -159,7 +159,7 @@ void RimIntersectionCollection::appendPartsToModel( Rim3dView&           view,
 //--------------------------------------------------------------------------------------------------
 void RimIntersectionCollection::rebuildGeometry()
 {
-    for ( RimIntersection* intersection : m_intersections )
+    for ( RimExtrudedCurveIntersection* intersection : m_intersections )
     {
         intersection->rebuildGeometry();
     }
@@ -173,7 +173,7 @@ void RimIntersectionCollection::rebuildGeometry()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimIntersection*> RimIntersectionCollection::intersections() const
+std::vector<RimExtrudedCurveIntersection*> RimIntersectionCollection::intersections() const
 {
     return m_intersections.childObjects();
 }
@@ -200,7 +200,7 @@ void RimIntersectionCollection::recomputeSimWellBranchData()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersectionCollection::appendIntersectionAndUpdate( RimIntersection* intersection, bool allowActiveViewChange )
+void RimIntersectionCollection::appendIntersectionAndUpdate( RimExtrudedCurveIntersection* intersection, bool allowActiveViewChange )
 {
     m_intersections.push_back( intersection );
 
@@ -220,7 +220,7 @@ void RimIntersectionCollection::appendIntersectionAndUpdate( RimIntersection* in
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimIntersectionCollection::appendIntersectionNoUpdate( RimIntersection* intersection )
+void RimIntersectionCollection::appendIntersectionNoUpdate( RimExtrudedCurveIntersection* intersection )
 {
     m_intersections.push_back( intersection );
 }
@@ -240,7 +240,7 @@ void RimIntersectionCollection::syncronize2dIntersectionViews()
 //--------------------------------------------------------------------------------------------------
 void RimIntersectionCollection::scheduleCreateDisplayModelAndRedraw2dIntersectionViews()
 {
-    for ( RimIntersection* isection : m_intersections )
+    for ( RimExtrudedCurveIntersection* isection : m_intersections )
     {
         if ( isection->correspondingIntersectionView() )
         {
@@ -302,9 +302,9 @@ bool RimIntersectionCollection::hasActiveIntersectionForSimulationWell( const Ri
 {
     if ( !isActive() ) return false;
 
-    for ( RimIntersection* cs : m_intersections )
+    for ( RimExtrudedCurveIntersection* cs : m_intersections )
     {
-        if ( cs->isActive() && cs->type() == RimIntersection::CS_SIMULATION_WELL && cs->simulationWell() == simWell )
+        if ( cs->isActive() && cs->type() == RimExtrudedCurveIntersection::CS_SIMULATION_WELL && cs->simulationWell() == simWell )
         {
             return true;
         }

ApplicationCode/ProjectDataModel/RimIntersectionCollection.h

@@ -24,7 +24,7 @@
 #include "cafPdmObject.h"
 
 class Rim3dView;
-class RimIntersection;
+class RimExtrudedCurveIntersection;
 class RimIntersectionBox;
 class RimEclipseCellColors;
 class RimSimWellInView;
@@ -52,8 +52,8 @@ public:
 
     caf::PdmField<bool> isActive;
 
-    void appendIntersectionAndUpdate( RimIntersection* intersection, bool allowActiveViewChange = true );
-    void appendIntersectionNoUpdate( RimIntersection* intersection );
+    void appendIntersectionAndUpdate( RimExtrudedCurveIntersection* intersection, bool allowActiveViewChange = true );
+    void appendIntersectionNoUpdate( RimExtrudedCurveIntersection* intersection );
 
     void appendIntersectionBoxAndUpdate( RimIntersectionBox* intersectionBox );
     void appendIntersectionBoxNoUpdate( RimIntersectionBox* intersectionBox );
@@ -73,7 +73,7 @@ public:
     void appendPartsToModel( Rim3dView& view, cvf::ModelBasicList* model, cvf::Transform* scaleTransform );
     void rebuildGeometry();
 
-    std::vector<RimIntersection*>    intersections() const;
+    std::vector<RimExtrudedCurveIntersection*>    intersections() const;
     std::vector<RimIntersectionBox*> intersectionBoxes() const;
 
 protected:
@@ -83,6 +83,6 @@ protected:
     caf::PdmFieldHandle* objectToggleField() override;
 
 private:
-    caf::PdmChildArrayField<RimIntersection*>    m_intersections;
+    caf::PdmChildArrayField<RimExtrudedCurveIntersection*>    m_intersections;
     caf::PdmChildArrayField<RimIntersectionBox*> m_intersectionBoxes;
 };

ApplicationCode/ProjectDataModel/RimIntersectionResultDefinition.cpp

@@ -25,7 +25,7 @@
 #include "RimGeoMechCase.h"
 #include "RimGeoMechCellColors.h"
 #include "RimGridView.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 #include "RimIntersectionResultsDefinitionCollection.h"
 #include "RimRegularLegendConfig.h"
 #include "RimTernaryLegendConfig.h"
@@ -287,7 +287,7 @@ void RimIntersectionResultDefinition::update2dIntersectionViews()
 {
     // Update 2D Intersection views
 
-    std::vector<RimIntersection*> intersections;
+    std::vector<RimExtrudedCurveIntersection*> intersections;
     this->objectsWithReferringPtrFieldsOfType( intersections );
 
     for ( auto intersection : intersections )

ApplicationCode/ProjectDataModel/RimModeledWellPath.cpp

@@ -25,7 +25,7 @@
 
 #include "RiaCompletionTypeCalculationScheduler.h"
 #include "RifTextDataTableFormatter.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 #include "RimPlotCurve.h"
 #include "RimWellPath.h"
 #include "RimWellPathFracture.h"
@@ -83,7 +83,7 @@ void RimModeledWellPath::updateWellPathVisualization()
         fracture->loadDataAndUpdate();
     }
 
-    std::vector<RimIntersection*> refferingIntersections;
+    std::vector<RimExtrudedCurveIntersection*> refferingIntersections;
     this->objectsWithReferringPtrFieldsOfType( refferingIntersections );
 
     for ( auto intersection : refferingIntersections )

ApplicationCode/ProjectDataModel/RimSimWellInView.cpp

@@ -31,7 +31,7 @@
 #include "RimCellRangeFilterCollection.h"
 #include "RimEclipseCase.h"
 #include "RimEclipseView.h"
-#include "RimIntersection.h"
+#include "RimExtrudedCurveIntersection.h"
 #include "RimIntersectionCollection.h"
 #include "RimPropertyFilterCollection.h"
 #include "RimSimWellFracture.h"