ArcObjects Library Reference (Geometry)

IConstructMultiPatch.ConstructExtrudeBetween Method

[Visual Basic .NET]
Public Sub ConstructExtrudeBetween ( _
    ByVal fromSurface As IFunctionalSurface, _
    ByVal toSurface As IFunctionalSurface, _
    ByVal baseGeom As IGeometry _
)

[C#]
public void ConstructExtrudeBetween (
    IFunctionalSurface fromSurface,
    IFunctionalSurface toSurface,
    IGeometry baseGeom
);

[C++]
HRESULT ConstructExtrudeBetween(
  IFunctionalSurface* fromSurface,
  IFunctionalSurface* toSurface,
  IGeometry* baseGeom
);

[C++]
Parameters
fromSurface 
  fromSurface is a parameter of type IFunctionalSurface
toSurface 
  toSurface is a parameter of type IFunctionalSurface
baseGeom 
  baseGeom is a parameter of type IGeometry

Available with ArcGIS Engine, ArcGIS Desktop, and ArcGIS Server.

[C#]

        private static object _missing = Type.Missing;

        public static IGeometry GetMultiPatchGeometry()

        {

            const double CircleDegrees = 360.0;

            const int CircleDivisions = 36;

            const double VectorComponentOffset = 0.0000001;

            const double CircleRadius = 9.5;

            const int PointCount = 100;

            const double UpperZMin = 7;

            const double UpperZMax = 10;

            const double LowerZMin = 0;

            const double LowerZMax = 3;

 

            //Extrusion: Circle Shaped Base Geometry Extruded Between Two Different TIN-Based Functional Surfaces

 

            IGeometryCollection multiPatchGeometryCollection = new MultiPatchClass();

 

            //Base Geometry

 

            IPointCollection polygonPointCollection = new PolygonClass();

 

            IPoint originPoint = ConstructPoint3D(0, 0, 0);

 

            IVector3D upperAxisVector3D = ConstructVector3D(0, 0, 10);

 

            IVector3D lowerAxisVector3D = ConstructVector3D(0, 0, -10);

 

            lowerAxisVector3D.XComponent += VectorComponentOffset;

 

            IVector3D normalVector3D = upperAxisVector3D.CrossProduct(lowerAxisVector3D) as IVector3D;

 

            normalVector3D.Magnitude = CircleRadius;

 

            double rotationAngleInRadians = GetRadians(CircleDegrees / CircleDivisions);

 

            for (int i = 0; i < CircleDivisions; i++)

            {

                normalVector3D.Rotate(-1 * rotationAngleInRadians, upperAxisVector3D);

 

                IPoint vertexPoint = ConstructPoint2D(originPoint.X + normalVector3D.XComponent,

                                                                        originPoint.Y + normalVector3D.YComponent);

 

                polygonPointCollection.AddPoint(vertexPoint, ref _missing, ref _missing);

            }

 

            IPolygon polygon = polygonPointCollection as IPolygon;

            polygon.Close();

 

            IGeometry baseGeometry = polygon as IGeometry;

 

            ITopologicalOperator topologicalOperator = polygon as ITopologicalOperator;

            topologicalOperator.Simplify();

 

            //Functional Surfaces

 

            IEnvelope envelope = new EnvelopeClass();

            envelope.XMin = -10;

            envelope.XMax = 10;

            envelope.YMin = -10;

            envelope.YMax = 10;

 

            Random random = new Random();

 

            //Upper Functional Surface

 

            ITinEdit upperTinEdit = new TinClass();

            upperTinEdit.InitNew(envelope);

 

            for (int i = 0; i < PointCount; i++)

            {

                double x = envelope.XMin + (envelope.XMax - envelope.XMin) * random.NextDouble();

                double y = envelope.YMin + (envelope.YMax - envelope.YMin) * random.NextDouble();

                double z = UpperZMin + (UpperZMax - UpperZMin) * random.NextDouble();

 

                IPoint point = ConstructPoint3D(x, y, z);

 

                upperTinEdit.AddPointZ(point, 0);

            }

 

            IFunctionalSurface upperFunctionalSurface = upperTinEdit as IFunctionalSurface;

 

            //Lower Functional Surface

 

            ITinEdit lowerTinEdit = new TinClass();

            lowerTinEdit.InitNew(envelope);

 

            for (int i = 0; i < PointCount; i++)

            {

                double x = envelope.XMin + (envelope.XMax - envelope.XMin) * random.NextDouble();

                double y = envelope.YMin + (envelope.YMax - envelope.YMin) * random.NextDouble();

                double z = LowerZMin + (LowerZMax - LowerZMin) * random.NextDouble();

 

                IPoint point = ConstructPoint3D(x, y, z);

 

                lowerTinEdit.AddPointZ(point, 0);

            }

 

            IFunctionalSurface lowerFunctionalSurface = lowerTinEdit as IFunctionalSurface;

 

            IConstructMultiPatch constructMultiPatch = new MultiPatchClass();

            constructMultiPatch.ConstructExtrudeBetween(upperFunctionalSurface, lowerFunctionalSurface, baseGeometry);

 

            return constructMultiPatch as IGeometry;

        }

 

        private static IVector3D ConstructVector3D(double xComponent, double yComponent, double zComponent)

        {

            IVector3D vector3D = new Vector3DClass();

            vector3D.SetComponents(xComponent, yComponent, zComponent);

 

            return vector3D;

        }

 

        private static double GetRadians(double decimalDegrees)

        {

            return decimalDegrees * (Math.PI / 180);

        }

 

        private static IPoint ConstructPoint3D(double x, double y, double z)

        {

            IPoint point = ConstructPoint2D(x, y);

            point.Z = z;

 

            return point;

        }

 

        private static IPoint ConstructPoint2D(double x, double y)

        {

            IPoint point = new PointClass();

            point.PutCoords(x, y);
 

            return point;

        }