ifeature.h

GIS格式转换软件vc源码.GIS格式转换软件vc源码.

   virtual void setAttribute(const char* attrName) = 0;

   // -----------------------------------------------------------------------
   /*! This one sets an attribute, but in such a way that the sequence
   // is remembered.  This is needed for schema features, to preserve
   // the order of attributes. */
   virtual void setSequencedAttribute(const char* attrName,
                                      const char* attrValue) = 0;

   // -----------------------------------------------------------------------
   /*! These methods set/get the feature type of the FME Feature.
   // The feature type is often also called the "class" or 
   // "category" of the feature. */

   // -----------------------------------------------------------------------
   /*! This method sets the feature type of the FME Feature.
   // The feature type is often also called the "class" or "category" 
   // of the feature. */
   virtual void setFeatureType(const char* featureType) = 0;

   // -----------------------------------------------------------------------
   /*! This method gets the feature type of the FME Feature.
   // The feature type is often also called the "class" or "category" 
   // of the feature. */
   virtual void getFeatureType(IFMEString& featureType) const = 0;

   // -----------------------------------------------------------------------
   /*! This method gets the feature type of the FME Feature.
   // The feature type is often also called the "class" or "category" 
   // of the feature. */
   virtual const char* getFeatureType() const = 0;

   // -----------------------------------------------------------------------
   /*! This methods sets the geometry type of the FME Feature.
   // The geometry type provides an indication of the kind of geometry
   // that is held in the feature. */
   virtual void setGeometryType(const FME_GeometryType geomType) = 0;

   // -----------------------------------------------------------------------
   /*! This methods gets the geometry type of the FME Feature.
   // The geometry type provides an indication of the kind of geometry
   // that is held in the feature. */
   virtual FME_GeometryType getGeometryType() const = 0;

   // -----------------------------------------------------------------------
   /*! This method gets the dimension of the feature. */
   virtual FME_Dimension getDimension() const = 0;

   // -----------------------------------------------------------------------
   /*! This method sets the dimension of the feature. */
   virtual void setDimension(const FME_Dimension dimension) = 0;

   // -----------------------------------------------------------------------
   /*! This method returns the number of coordinates in a feature. 
   //  This is deprecated as  it returns the (number of vertices) + (number of parts)
   //  for multi-part features.  See numVertices() method below.*/
   virtual FME_UInt32 numCoords() const = 0;

   // -----------------------------------------------------------------------
   /*! This method resets the number of coordinates in the feature to 0. */
   virtual void resetCoords() = 0;

   // -----------------------------------------------------------------------
   /*! This method accesses the feature's individual coordinates by index. 
   // The index must be in the range 0 .. (numCoords() - 1); if it is 
   // outside the valid range, an error will occur, and the coordinates
   // will be set to kFME_noCoordinate.*/
   virtual FME_MsgNum getCoordinate(const FME_UInt32 index, 
                                    FME_Real64& xCoord, 
                                    FME_Real64& yCoord) const = 0;

   // -----------------------------------------------------------------------
   /*! This method accesses the feature's individual coordinates by index. 
   // The index must be in the range 0 .. (numCoords() - 1); if it is 
   // outside the valid range, an error will occur, and the coordinates
   // will be set to kFME_noCoordinate.
   // NOTE: If this method is used to access the coordinates of a two 
   // dimensional coordinate, the Z coordinate will be set to 0 */
   virtual FME_MsgNum getCoordinate(const FME_UInt32 index, 
                                    FME_Real64& xCoord, 
                                    FME_Real64& yCoord, 
                                    FME_Real64& zCoord) const = 0;

   // -----------------------------------------------------------------------
   /*! This method accesses the feature's individual X coordinates by index.
   // The index must be in the range 0 .. (numCoords() - 1); if it is 
   // outside the valid range, kFME_noCoordinate will be returned. */
   virtual FME_Real64 getXCoordinate(const FME_UInt32 index) const = 0;

   // -----------------------------------------------------------------------
   /*! This method accesses the feature's individual Y coordinates by index.
   // The index must be in the range 0 .. (numCoords() - 1); if it is 
   // outside the valid range, kFME_noCoordinate will be returned. */
   virtual FME_Real64 getYCoordinate(const FME_UInt32 index) const = 0;

   // -----------------------------------------------------------------------
   /*! This method accesses the feature's individual Z coordinates by index.
   // The index must be in the range 0 .. (numCoords() - 1); if it is 
   // outside the valid range, kFME_noCoordinate will be returned. 
   // NOTE: If this method is used to access the Z coordinates of a two 
   // dimensional coordinate, 0 will always be returned.*/
   virtual FME_Real64 getZCoordinate(const FME_UInt32 index) const = 0;

   // -----------------------------------------------------------------------
   /*! This method adds coordinates onto an existing FME feature.
   // Default values of zero are added in place of missing values 
   // if necessary. If the feature is two dimensional, any provided
   // Z coordinate will be ignored. */
   virtual void addCoordinate(const FME_Real64 xCoord = 0,
                              const FME_Real64 yCoord = 0, 
                              const FME_Real64 zCoord = 0) = 0;

   // -----------------------------------------------------------------------
   /*! This methods gets the coordinate system string associated
   // with the FME feature.  This string is the identifier of the coordinate
   // system used by the feature.  See the IFMECoordSysManager
   // definition for more information on manipulating this identifier. */
   virtual void getCoordSys(IFMEString& coordSys) const = 0;

   // -----------------------------------------------------------------------
   /*! This methods gets the coordinate system string associated
   // with the FME feature.  This string is the identifier of the coordinate
   // system used by the feature.  See the IFMECoordSysManager
   // definition for more information on manipulating this identifier. */
   virtual const char* getCoordSys() const = 0;

   // -----------------------------------------------------------------------
   /*! This methods sets the coordinate system string associated
   // with the FME feature.  This string is the identifier of the coordinate
   // system used by the feature.  See the IFMECoordSysManager
   // definition for more information on manipulating this identifier. */
   virtual void setCoordSys(const char* newCoordSys) = 0;

   // -----------------------------------------------------------------------
   /*! This method provides a method of calling any of the FME functions
   // on the feature.  See the FME documentation for the format of the
   // functions.  The function string passed in to this function follows
   // the syntax of the manual exactly. Note that no spaces should be
   // present between any parameters of the function, or between the 
   // function name and the ( */
   virtual FME_MsgNum performFunction(const char* functionSpecification,
                                      IFMEString& funcResult) = 0; 

   // -----------------------------------------------------------------------
   /*! This method resets (clears) all the attributes and geometry of the feature.  
   // It results in a fresh clean feature.  (When using FMEObjects: This
   // method is used to reset a feature after it has been passed to a 
   // writer preparing it for loading of new data.  This needs to be 
   // done if you are loading a feature outside of FMEObjects.  
   // If you are giving a feature to IFMEReader then there is no 
   // need to call this method.) */
   virtual FME_MsgNum resetFeature() = 0;

   // -----------------------------------------------------------------------
   /*!  This method sets the features passed in to be an exact duplicate 
   // of the feature this is called on.  All attributes and geometry of the 
   // destFeature will be erased by this method. */
   virtual FME_MsgNum clone(IFMEFeature& destFeature) const = 0;

   // -----------------------------------------------------------------------
   /*! This routine sets the featureType and the attributes of the feature
   // passed in to be exact duplicates of the feature this is called on.
   // The geometry is not touched.  The caller should previously have set up the
   // geometry type for the passed in destFeature.  The original attributes on the
   // destFeature are lost. */
   virtual FME_MsgNum cloneAttributes(IFMEFeature& destFeature) const = 0;

   // -----------------------------------------------------------------------
   /*! This routine sets the featureType and the attributes of the feature
   // passed in from the feature this is called on, ONLY if those attributes 
   // are not already present.  The geometry is not touched.  The caller 
   // should previously have set up the geometry type for the passed in 
   // destFeature.  The original attributes on the destFeature are not lost. */
   virtual FME_MsgNum mergeAttributes(IFMEFeature& destFeature) const = 0;

   // -----------------------------------------------------------------------
   /*! Rotates in the counterclockwise direction by specified number of
   // degrees */
   virtual FME_MsgNum rotate2D(const FME_Real64 originX,
                               const FME_Real64 originY,
                               const FME_Real64 degreeAngle) = 0;

   // -----------------------------------------------------------------------
   /*! Scales the feature by the given amounts.  (2D or 3D) */
   virtual FME_MsgNum scale(const FME_Real64 scaleX,
                            const FME_Real64 scaleY,
                            const FME_Real64 scaleZ = 1.0) = 0;
   
   // -----------------------------------------------------------------------
   /*!    Offsets the feature by the given amounts.  (2D or 3D) */
   virtual FME_MsgNum offset(const FME_Real64 offsetX,
                             const FME_Real64 offsetY,
                             const FME_Real64 offsetZ = 0.0) = 0;

   // -----------------------------------------------------------------------
   /*! Strokes an arc feature to be a polygon or line. */
   virtual FME_MsgNum convertArcToPoints(const FME_Real64 centerX, 
                                         const FME_Real64 centerY, 
                                         const FME_Real64 semiPrimaryAxis, 
                                         const FME_Real64 semiSecondaryAxis, 
                                         const FME_UInt32 origNumSamps, 
                                         const FME_Real64 startAngle,
                                         const FME_Real64 endAngle, 
                                         const FME_Real64 rotation) = 0;

   // -----------------------------------------------------------------------
   /*! Converts the feature into a point feature with attributes required
   // to define it as an arc.  If the feature has more than 3 points, the
   // arc is approximated. */
   virtual FME_MsgNum convertPointsToArc(const char* radiusAttrName,
                                         const char* startAngleAttrName,
                                         const char* sweepAngleAttrName) = 0;
 
   // -----------------------------------------------------------------------
   /*! Performs interpolation on the passed in feature. */
   virtual FME_MsgNum interpolateSpline(const FME_UInt32 numPointsPerSegment,
                                        const FME_Boolean calcPhantomPoints) = 0;

   // -----------------------------------------------------------------------
   /*! This method returns the bounding box of a feature */
   virtual FME_MsgNum boundingBox(FME_Real64& minx, FME_Real64& maxx, 
                                  FME_Real64& miny, FME_Real64& maxy) const = 0;

   // -----------------------------------------------------------------------
   /*! This method returns the bounding cube of a feature */
   virtual FME_MsgNum boundingCube(FME_Real64& minx, FME_Real64& maxx, 
                                   FME_Real64& miny, FME_Real64& maxy,
                                   FME_Real64& minz, FME_Real64& maxz) const = 0;
                                   
   // -----------------------------------------------------------------------
   /*! This method generates a point somewhere inside the polygon.
   // The "pretty" flag can be used to generate a point that has a more
   // central position, however more computational time may be required.
   // If the feature is 3D, the Z value is calculated to be the average 
   // of all points on the feature. */
   virtual FME_MsgNum generatePointInPolygon(FME_Real64&  internalPointX,
                                             FME_Real64&  internalPointY,
                                             FME_Real64&  internalPointZ,
                                             const FME_Boolean pretty = FME_FALSE ) const = 0;

   // -----------------------------------------------------------------------
   /*! This method converts a feature into an aggregate, if it contains more 
   // than the threshold of vertices, where each member of the aggregate has 
   // fewer than the threshold number of vertices.  If the feature was an 
   // area based feature, it will do area chopping, subdividing the area so 
   // that no area piece has more than the number of vertices. If the feature 
   // was linear, then the line is broken into chunks that meet the size 
   // criteria. */
   virtual FME_MsgNum chopUp(const FME_UInt32 vertexThreshold, 
                             FME_Boolean& featureChopped) = 0;

   // -----------------------------------------------------------------------
   /*! This method creates an aggregate feature from the passes in
   // featureArray.  The aggregate is constructed and the feature
   // vector is returned empty.  All the features passed in are
   // deleted.  */
   virtual FME_MsgNum buildAggregateFeat(IFMEFeatureVector& parts) = 0;

   // -----------------------------------------------------------------------
   /*! This method splits up an aggregate feature into pieces, all of which 
   // have the same attributes and feature type.  If the recurse flag is set,
   // all aggregates within the aggregate are also split, recursively, so
   // no aggregates are ever returned as pieces. */
   virtual FME_MsgNum splitAggregate(IFMEFeatureVector& parts,