ifeature.h

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

   // the order of the parameters should be m11, m12, m21 and m22.
   // After doing the transformation, it sets the coordinates of the feature
   // accordingly. 
   */
   virtual FME_MsgNum matrixTransform(FME_Real64 m11,
                                      FME_Real64 m12,
                                      FME_Real64 m21,
                                      FME_Real64 m22) = 0;

   // -----------------------------------------------------------------------
   /*! This method performs a 3D matrix transformation on the feature. 
   // The order in which parameters are passed in is important and it should 
   // be row wise e.g. for a matrix
   <pre>
        | m11 m12 m13 |
        | m21 m22 m23 |
        | m31 m32 m33 |
   </pre>
   // the order of the parameters should be m11, m12, m13, m21, m22, m23,
   // m31, m32m and m33. 
   // After doing the transformation, it sets the coordinates of the feature
   // accordingly.    */
   virtual FME_MsgNum matrixTransform(FME_Real64 m11,
                                      FME_Real64 m12,
                                      FME_Real64 m13,
                                      FME_Real64 m21,
                                      FME_Real64 m22,
                                      FME_Real64 m23,
                                      FME_Real64 m31,
                                      FME_Real64 m32,
                                      FME_Real64 m33) = 0;

   // -----------------------------------------------------------------------
   /*! This method a part iterator for the current feature geometry.   
   // The feature cannot be deleted before the iterator as the iterator merely
   // provides an efficient method of walking thru pieces of the geometry.
   // If the feature geometry is changed in any way then the iterator is
   // invalid and must be destroyed.
   // If flatten is specified
   // then the iterator breaks down all embedded aggregates to their primitive
   // geometry types, otherwise it will return aggregate parts which must
   // be split by getting another part iterator from the returned iterator.
   // If splitDonuts is specified
   // then the iterator iterates through all the rings of donuts and returns
   // them as polygons, otherwise it will return donuts as one complete piece. */
   virtual IFMEPartIterator *getPartIterator(const FME_Boolean flatten, const FME_Boolean splitDonuts)= 0;

   // -----------------------------------------------------------------------
   /*! This method destroys a part iterator created by this feature. 
   // Part iterators created by another part iterator should be destroyed by 
   // the part iterator that created it.  */
   virtual void destroyPartIterator(IFMEPartIterator* &partIter) = 0;

   // -----------------------------------------------------------------------
   /*! This method returns FME_TRUE if the feature has geometry and FME_FALSE
   //  otherwise. */
   virtual FME_Boolean hasGeometry() const = 0;

   // -----------------------------------------------------------------------
   /*! This method returns the actual number of vertices that make up the 
   // geometry of the feature.  It handles multi-part (aggregate) 
   // geometries properly.  For simple geometries it returns the 
   // same value as the deprecated function numCoords().   */
   virtual FME_UInt32 numVertices() const = 0;

   // -----------------------------------------------------------------------
   /*! This method returns the number of parts that make up the  geometry of 
   // the feature. If flatten is specified, then it returns the number of 
   // primitive parts drilling down into sub aggregates if there are some.  
   // If flatten is false then it returns the number of high level parts with 
   // some parts potentially being aggregates.  If splitDonuts is true it will
   // count the rings of a donut as separate parts.
   */
   virtual FME_UInt32 numParts(const FME_Boolean flatten,
                               const FME_Boolean splitDonuts) const = 0;

   // -----------------------------------------------------------------------
   /*! This searches for the list attribute by name and removes it from the 
   // feature if it is found. */
   virtual void removeListAttribute(const char* attrName) = 0;

   //---------------------------------------------------------------------
   /*! This returns the number of bytes required by serialize() to store an IFMEFeature.
   //  Parameters is optional; as such, NULL may be passed in for parameters.  
   //
   // The possible name-value pairs are:
   // <dl>
   // <dt><b>fme_feature_serialize_option</b>(C++ Constant: kFME_FeatureSerializeOption)</dt>
   // <dd>
   //    <dl>
   //    <dt><b>fme_feature_full_feature</b>(C++ Constant: kFME_FeatureFullFeature)</dt>
   //    <dd>  (Default)
   //          Get the number of bytes required for serializing the full feature. 
   //          (geometry + attributes)
   //    </dd>
   //    </dl> 
   //
   //    <dl>
   //    <dt><b>fme_feature_geometry</b>(C++ Constant: kFME_FeatureGeometry)</dt>
   //    <dd>
   //          Get the number of bytes required for serializing the geometry portion of
   //          a feature only. (This includes coordinates, coordinate system, and
   //          geometry attributes.)
   //    </dd>
   //    </dl> 
   // </dd>
   // <dt><b>fme_feature_serialize_exclude_attr</b>(C++ Constant: kFME_FeatureSerializeExcludeAttr)</dt>
   // <dd>
   //    <dl>
   //    <dt><b>Attribute name to exclude</b></dt>
   //    <dd>  The name of the attribute to exclude when doing feature serialization.
   //          This name-value pair can be repeated.
   //    </dd>
   //    </dl> 
   // </dd>
   // </dl> */
   virtual FME_UInt32 serializeSize(IFMEStringArray* parameters) const = 0;

   //---------------------------------------------------------------------
   /*! This writes the state of the IFMEFeature to the specified buffer.
   //  It is the caller's responsibility that this buffer is allocated with
   //  sufficient space.  The caller owns the buffer.  FME_TRUE is returned
   //  on success.
   //  The size passed in is the total length of the buffer.
   //  Parameters is optional; as such, NULL may be passed in for parameters.  
   //
   // The possible name-value pairs for parameters are:
   // <dl>
   // <dt><b>fme_feature_serialize_option</b>(C++ Constant: kFME_FeatureSerializeOption)</dt>
   // <dd>
   //    <dl>
   //    <dt><b>fme_feature_full_feature</b>(C++ Constant: kFME_FeatureFullFeature)</dt>
   //    <dd>  (Default)
   //          Serializes the full feature. (geometry + attributes)
   //    </dd>
   //    </dl> 
   //
   //    <dl>
   //    <dt><b>fme_feature_geometry</b>(C++ Constant: kFME_FeatureGeometry)</dt>
   //    <dd>
   //          Serializes the geometry portion of a feature only. (This includes
   //          coordinates, coordinate system, and geometry attributes.)
   //    </dd>
   //    </dl> 
   // </dd>
   // <dt><b>fme_feature_serialize_exclude_attr</b>(C++ Constant: kFME_FeatureSerializeExcludeAttr)</dt>
   // <dd>
   //    <dl>
   //    <dt><b>Attribute name to exclude</b></dt>
   //    <dd>  The name of the attribute to exclude when doing feature serialization.
   //          This name-value pair can be repeated.
   //    </dd>
   //    </dl> 
   // </dd>
   // </dl> */
   virtual FME_Boolean serialize(unsigned char* buffer, FME_UInt32 size, IFMEStringArray* parameters) const = 0;

   //---------------------------------------------------------------------
   /*! This restores the state of the IFMEFeature from the specified buffer.
   //  The caller owns the buffer.  FME_TRUE is returned on success.
   //  The size passed in is the total length of the buffer.
   //  Parameters is optional; as such, NULL may be passed in for parameters.  
   //
   // The possible name-value pairs for parameters are:
   // <dl>
   // <dt><b>fme_feature_deserialize_option</b>(C++ Constant: kFME_FeatureDeserializeOption)</dt>
   // <dd>
   //    <dl>
   //    <dt><b>fme_feature_deserialize_reset</b>(C++ Constant: kFME_FeatureDeserializeReset)</dt>
   //    <dd>  (Default)
   //          Resets the original feature before restoring the state of the IFMEFeature from the 
   //          specified buffer.
   //    </dd>
   //    </dl> 
   //
   //    <dl>
   //    <dt><b>fme_feature_deserialize_merge</b>(C++ Constant: kFME_FeatureDeserializeMerge)</dt>
   //    <dd>
   //          Restores the state of the IFMEFeature from the specified buffer,  
   //          the original feature will NOT be reset; the original information 
   //          in the feature will be preserved if there is no corresponding 
   //          information in the buffer.  (Attributes, geometry, coordinate system
   //          information, etc. taken from the buffer will overwrite such information
   //          on the feature if necessary.)
   //    </dd>
   //    </dl> 
   // </dd>
   // </dl> */
   virtual FME_Boolean deserialize(const unsigned char* buffer, FME_UInt32 size, IFMEStringArray* parameters) = 0;

   // -----------------------------------------------------------------------
   /*! Strokes an arc feature to be a polygon or line. */
   virtual FME_MsgNum convertAnyArcToPoints(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 sweepAngle, 
                                            const FME_Real64 rotation) = 0;
   
   //-----------------------------------------------------------------------
   /*! <b>BETA</b> - Preview of our new geometry technology. 
   // Safe Software reserves the right to release subsequent versions 
   // that require changes to applications that use this API.
   //
   // This removes the geometry from the feature and returns it.  The caller
   // is responsible for its destruction using the IFMEGeometryTools::destroyGeometry() 
   // method. */
   virtual IFMEGeometry* removeGeometry() = 0;

   //-----------------------------------------------------------------------
   /*! <b>BETA</b> - Preview of our new geometry technology. 
   // Safe Software reserves the right to release subsequent versions 
   // that require changes to applications that use this API.
   //
   // This returns a pointer to the feature's geometry. The feature retains
   // ownership of the geometry. */
   virtual const IFMEGeometry* getGeometry() = 0;
   
   //-----------------------------------------------------------------------
   /*! <b>BETA</b> - Preview of our new geometry technology. 
   // Safe Software reserves the right to release subsequent versions 
   // that require changes to applications that use this API.
   //
   // This gives the geometry to the feature.  Any geometry the feature used
   // to have is lost.  The caller gives up responsibility for the object
   // passed in.  Passing in NULL clears the geometry on the feature. */
   virtual void setGeometry(IFMEGeometry* geometry) = 0;

   //-----------------------------------------------------------------------
   /*! <b>BETA</b> - Preview of our new geometry technology. 
   // Safe Software reserves the right to release subsequent versions 
   // that require changes to applications that use this API.
   //
   // This will return true if the feature's geometry takes advantage
   // of the new geometry technology. */
   virtual FME_Boolean hasRichGeometry() const = 0;

protected:
   // -----------------------------------------------------------------------
   // No one should be creating an instance of this directly, so we
   // make the constructor protected.
   IFMEFeature() {}; 

   // -----------------------------------------------------------------------
   // Destructor -- does nothing
   virtual ~IFMEFeature() {};
 
private:
    // Hide methods that we don't want called.
    // -----------------------------------------------------------------------
   // copy constructor
   IFMEFeature(const IFMEFeature&);

   // -----------------------------------------------------------------------
   // assignment operator.
   IFMEFeature& operator=(const IFMEFeature&);
};

#endif