ifeature.h

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

                                     const FME_Boolean recurse = FME_FALSE) const = 0;

   // -----------------------------------------------------------------------
   /*! This method breaks a donut feature into its constituent parts. The
   // first part is the outer shell of the donut polygon and the following
   // parts are the holes.  All of the parts have the same attributes and
   // feature type as the original feature. */
   virtual FME_MsgNum getDonutParts(IFMEFeatureVector& parts) const = 0;

   // -----------------------------------------------------------------------
   /*! This method constructs a donut polygon from the features in the
   // input feature array.  If the resulting feature builds multiple 
   // donut features then the geometry of the current feature is an
   // aggregate of donuts. The feature geometry is constructed using copies of
   // the passed in features.  The passed in features are deleted and
   // the array is returned empty.  When this function is called the
   // client is relinguishing all control over the features in the
   // featureArray. */
   virtual FME_MsgNum makeDonuts(IFMEFeatureVector& parts,
                                 const FME_Boolean keepHoles = FME_FALSE ) = 0;

   // -----------------------------------------------------------------------
   /*! This method provides a convenient interface for retrieving a list attribute.
   // The list attribute value is returned in attrValues. An example
   // list name could be "adjacentIds", which would cause the attrValues
   // array to hold all the values found for "adjacentIds{0} ... 
   // adjacentIds{N}".  The function also accepts a "structured list"
   // specification, such as "attrInfo{}.name", which would cause
   // the attrValues array to hold all the values found for 
   // "attrInfo{0}.name ... attrInfo{N}.name" */
   virtual FME_Boolean getListAttribute(const char* attrName,
                                        IFMEStringArray& attrValues) const = 0;

   // -----------------------------------------------------------------------
   /*! This method provides a convenient interface for storing the contents of
   // an IFMEStringArray as a list attribute on the feature. */
   virtual void setListAttribute(const char* attrName,
                                 const IFMEStringArray& attrValues) = 0;

   // -----------------------------------------------------------------------
   /*! This method gets a list of sequenced attribute names in the order,
   // they were added to the feature. */
   virtual void getSequencedAttributeList(IFMEStringArray& attrNames) const = 0;

   // -----------------------------------------------------------------------
   /*! This method adjusts a multi-poly/donutpoly so that either the right hand
   // or the left hand rule is followed.
   // With the right hand rule, the area of the polygon is always on the
   // right and the coordinates of the outer boundary are in the clockwise
   // direction, and for any holes they are counterclockwise.
   // Returns an error if its called on a feature whose geometryType isn't a 
   // polygon or multipolygon */
   virtual FME_MsgNum orient(const FME_OrientationRule rightOrLeft) = 0;

   // -----------------------------------------------------------------------
   /*! This method returns the orientation rule of the feature.
   // It only does the outer shell of the polygon or line. */
   virtual FME_OrientationRule orient() const = 0;

   // -----------------------------------------------------------------------
   /*! This method reprojects the feature from its current coordinate
   //  system to that specified. If the feature has no coordinate system
   // specified then this has the same effect as the setCoordSys method. */
   virtual FME_MsgNum reproject(const char* coordSys) = 0;

   // -----------------------------------------------------------------------
   /*! This method generates a buffer around the feature.  The features
   //  geometry is replaced by the new buffer geometry.  If the feature
   //  is an area feature then the buffer is only generated on the outside
   //  (and inside holes) of the feature. The buffer is width ground
   //  units around the feature.  The strokeAngle identifies the sampling
   //  angle. If 5 then there is a vertex on the buffer every 5 degrees.*/
   virtual FME_MsgNum buffer(FME_Real64 width, FME_Real64 sampleAngle) = 0;

   // -----------------------------------------------------------------------
   /*! This method results in the geometry of a donut feature being 
   //  changed to just its outerShell.  If called on non-area features
   //  then the method has no effect. */
   virtual FME_MsgNum outerShell() = 0;

   // -----------------------------------------------------------------------
   /*! This method converts the geometry of the feature to the OGC
   //  Well Known Text (ASCII) format.  The OGC representation is returned
   //  in the passed in string OGCWKT */
   virtual FME_MsgNum exportGeometryToOGCWKT(IFMEString &OGCWKT) const = 0;

   // -----------------------------------------------------------------------
   /*! This method sets the geometry of the feature to be that specified in
   // the OGC Well Known Text (ASCII) format.  If the feature currently
   // has geometry at the time this method was called then the geometry
   // is replaced by that specified in the string OGCWKT. */
   virtual FME_MsgNum importGeometryFromOGCWKT(const char *OGCWKT) = 0;

   // -----------------------------------------------------------------------
   /*! This method converts the geometry of the feature to the OGC
   //  Well Known Binary format.  The OGC representation is returned in 
   //  the  passed in string object. */
   virtual FME_MsgNum exportGeometryToOGCWKB(IFMEString &OGCWKB) const = 0;

   // -----------------------------------------------------------------------
   /*! This method sets the geometry of the feature to be that specified in
   // the OGC Well Known Binary format.  If the feature currently
   // has geometry at the time this method was called then the geometry
   // is replaced by that specified in the string OGCWKB. */
   virtual FME_MsgNum importGeometryFromOGCWKB(const IFMEString &OGCWKB) = 0;

   // -----------------------------------------------------------------------
   /*! This method gets the entire geometry of the feature in one call.
   // The arrays passed in to this call must be allocated by the client
   // before this method is called.  The arrays must have at least
   // numCoords() entries allocated before this method is called.  The
   // third parameter is optional; if z is NULL or if getDimension() is
   // FME_TWO_D nothing will be copied into z.  The client is also responsible
   // for releasing any memory allocated in the arrays after using them. */
   virtual void getAllCoordinates(const FME_Real64* x,
                                  const FME_Real64* y,
                                  const FME_Real64* z = 0) const = 0;

   // -----------------------------------------------------------------------
   /*! This method adds to the geometry of the feature in one call.
   // The current geometry kept and appended to with the coordinates
   // present in the arrays.  The arrays passed in to this call must 
   // be allocated by the client before this method is called and must
   // have at least numCoords entries allocated.  The fourth
   // parameter is optional; if z is NULL or the feature is 2D, the feature
   // will become (or remain) 2D.  Otherwise the feature will remain 3D.
   // The client is also responsible for releasing any memory allocated
   // in the arrays after using them. */
   virtual void addCoordinates(const FME_UInt32 numCoords,
                               const FME_Real64* x,
                               const FME_Real64* y,
                               const FME_Real64* z = 0) = 0;

   // -----------------------------------------------------------------------
   /*!  This method performs some general processing operation on 
   // a vector of features.  When this function is called the client 
   // is relinquishing all control over the features in the featureVector.
   // Depending on the operation, the feature array may be returned
   // empty (cleared and destroyed), or containing some features (whose
   // ownership is returned to the caller).
   // The operation performed is governed by the contents of the 
   // "parms" array.  The first entry in this array determines the
   // the kind of operation. The following operations are supported
   // (more may be added later):
   // <dl>
   //     <dt><b>"fme_convert_to_area"</b> (C++ Constant: kFME_ConvertToArea)</dt>
   //     <dd>   If this is the value of the first parameter
   //            in the string array, then the contents of the feature array are
   //            assumed to be a collection of lines.  These lines are then
   //            formed into polygons.  Any unused line pieces are returned
   //            in the feature array. If there are no unused line pieces
   //            then the feature array is returned empty.
   //            The polygons which result are turned into donuts and aggregated
   //            Any "holes" are themselves dropped from result.  The single
   //            resulting area geometry is finally applied to the feature
   //            upon which the call was made.<br>
   //            If there is a second entry in the "parms" array, and this entry
   //            is kFME_DropLines, then the unused line pieces are deleted and
   //            the feature vector will always be returned empty. <br>
   //            If no polygon at all was formed, a non-zero status will be
   //            returned.  The feature itself will have undefined geometry,
   //            and the featureArray will have all the line pieces, 
   //            unless the kFME_DropLines directive was specified.
   // </dd>
   //     <dt><b>"fme_polygon_dissolve"</b> (C++ Constant: kFME_PolygonDissolve)</dt>
   //     <dd>   If this is the value of the first parameter
   //            in the string array, then the contents of the feature array are 
   //            assumed to be a collection of polygons. If there are non-polygon
   //            features, then they will be filtered out. The collection of polygon
   //            features will be dissolved and the result will be applied to the 
   //            feature upon which the call was made.  The feature array will
   //            have all the interior lines.  Dissolved polygons are those polygons
   //            formed when shared edges between adjacent polygons are removed. This 
   //            operation assumes that all input polygons are properly noded, a vertex
   //            is present at each intersection point, and that polygons are not 
   //            overlapping.<br>
   //            If there is a second entry in the "parms" array, and this entry
   //            is kFME_DropLines, then all the interior lines will be deleted and
   //            the feature vector will always be returned empty.<br>
   //            If no polygon at all was formed, a non-zero status will be
   //            returned.  The feature itself will have undefined geometry,
   //            and the featureArray will have all interior lines, 
   //            unless the kFME_DropLines directive was specified.
   // </dd>
   // </dl>
   // */
   virtual FME_MsgNum processFeatures(IFMEFeatureVector& featureArray,
                                      const IFMEStringArray& parms) = 0;

   // -----------------------------------------------------------------------
   /*!  This method performs some general processing operation on 
   // a vector of features this is on disk.  When this function is called the 
   // client is relinquishing all control over the features in the featureVector.
   // Depending on the operation, the feature array may be returned empty 
   // (cleared and destroyed), or containing some features (whose ownership is 
   // returned to the caller). The operation performed is governed by the 
   // contents of the "parms" array.  The first entry in this array determines
   // the kind of operation. The following operations are supported
   // (more may be added later): 
   // <dl>
   //     <dt><b>"fme_convert_to_area"</b> (C++ Constant: kFME_ConvertToArea)</dt>
   //     <dd>   If this is the value of the first parameter
   //            in the string array, then the contents of the feature array are
   //            assumed to be a collection of lines.  These lines are then
   //            formed into polygons.  Any unused line pieces are returned
   //            in the feature array. If there are no unused line pieces
   //            then the feature array is returned empty.
   //            The polygons which result are turned into donuts and aggregated
   //            Any "holes" are themselves dropped from result.  The single
   //            resulting area geometry is finally applied to the feature
   //            upon which the call was made.<br>
   //            If there is a second entry in the "parms" array, and this entry
   //            is kFME_DropLines, then the unused line pieces are deleted and
   //            the feature vector will always be returned empty.<br>
   //            If no polygon at all was formed, a non-zero status will be
   //            returned.  The feature itself will have undefined geometry,
   //            and the featureArray will have all the line pieces, 
   //            unless the kFME_DropLines directive was specified.<br>
   // </dd>
   //     <dt><b>"fme_polygon_dissolve"</b> (C++ Constant: kFME_PolygonDissolve)</dt>
   //     <dd>   If this is the value of the first parameter
   //            in the string array, then the contents of the feature array are 
   //            assumed to be a collection of polygons. If there are non-polygon
   //            features, then they will be filtered out. The collection of polygon
   //            features will be dissolved and the result will be applied to the 
   //            feature upon which the call was made.  The feature array will
   //            have all the interior lines.  Dissolved polygons are those polygons
   //            formed when shared edges between adjacent polygons are removed. This 
   //            operation assumes that all input polygons are properly noded, a vertex
   //            is present at each intersection point, and that polygons are not 
   //            overlapping.<br>
   //            If there is a second entry in the "parms" array, and this entry
   //            is kFME_DropLines, then all the interior lines will be deleted and
   //            the feature vector will always be returned empty.<br>
   //            If no polygon at all was formed, a non-zero status will be
   //            returned. The feature itself will have undefined geometry,
   //            and the featureArray will have all interior lines, 
   //            unless the kFME_DropLines directive was specified.<br>  
   // </dd>
   // </dl>
   // */
   virtual FME_MsgNum processFeaturesOnDisk(IFMEFeatureVectorOnDisk& featureArray,
                                            const IFMEStringArray& parms) = 0;

   // -----------------------------------------------------------------------
   /*! This method eturns the attribute's value as a FME_Boolean value.
   // If no FME_Boolean value could be found, or the value found could not 
   // be converted, FME_FALSE will be returned. */
   virtual FME_Boolean getBooleanAttribute(const char* attrName,
                                           FME_Boolean& attrValue) const = 0;

   // -----------------------------------------------------------------------
   /*! This method supplies an FME_Boolean attribute to the feature. */
   virtual void setBooleanAttribute(const char* attrName,
                                    const FME_Boolean attrValue) = 0;

   // -----------------------------------------------------------------------
   /*! This method performs a 2D matrix transformation on the feature. 
   // The order in which parameters are passed is important and it should be 
   // row wise e.g. for a matrix
   <pre>
            | m11 m12 |
            | m21 m22 |
   </pre>