com.esri.arcgis.display
Interface IDisplayTransformation

All Superinterfaces:
ITransformation, Serializable
All Known Implementing Classes:
DisplayTransformation, IDisplayTransformationProxy

public interface IDisplayTransformation
extends ITransformation, Serializable

Provides access to members that control Display Transformation.

Product Availability

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

Supported Platforms

Windows, Solaris, Linux

When To Use

Use IDisplayTransformation for converting coordinates between real-world and device space and back.  To prepare a transform for use, follow these steps:

  1. Set the full map extent with the Bounds property
  2. Set the visible map extent (zoom rectangle) with the VisibleBounds property
  3. Set the output area of the device using the DeviceFrame property
  4. Set the resolution of the output device using the Resolution property

The transform is based on the ratio between the VisibleBounds and the DeviceFrame.  Normally the DeviceFrame is simply the full extent of the device with the origin equal to 0,0. 

The transform object calculates the FittedBounds automatically and this is the visible map extent adjusted to fit the device.

Remarks

Obtain an IDisplayTransformation reference to the DisplayTransformation object from IDisplay::DisplayTransformation . Because IScreenDisplay inherits from IDisplay, you can also use IScreenDisplay::DisplayTransformation.

Each DisplayTransformation manages a coordinate system object such as a GeographicCoordinateSystem or ProjectedCoordinateSystem . Obtain a reference to the display's coordinate system object using IDisplayTransformation::SpatialReference.

The DisplayTransformation of a PageLayout object does not have a spatial reference and translates between device units and page units.


Method Summary
 void fromMapPoint(IPoint mapPoint, int[] x, int[] y)
          Calculates device coordinates corresponding to the map point.
 double fromPoints(double pointDistance)
          Calculates a map distance corresponding to a point (1/72) distance.
 IEnvelope getBounds()
          Full extent in world coordinates.
 IEnvelope getConstrainedBounds()
          Intersection of Bounds and VisibleBounds.
 tagRECT getDeviceFrame()
          Visible extent in device coordinates.
 IEnvelope getFittedBounds()
          Device frame in world coordinates.
 double getReferenceScale()
          Reference scale for computing scaled symbol sizes.
 double getResolution()
          Resolution of the device in dots (pixels) per inch.
 double getRotation()
          Rotation angle in degrees.
 double getScaleRatio()
          Scale between FittedBounds and DeviceFrame.
 ISpatialReference getSpatialReference()
          Current spatial reference.
 int getUnits()
          Units used by world coordinates.
 IEnvelope getVisibleBounds()
          Visible extent in world coordinates.
 boolean isSuppressEvents()
          Indicates if transformation object suppresses events.
 boolean isZoomResolution()
          Indicates if resolution is tied to visible bounds.
 void setBounds(IEnvelope bounds)
          Full extent in world coordinates.
 void setDeviceFrame(tagRECT bounds)
          Visible extent in device coordinates.
 void setReferenceScale(double scale)
          Reference scale for computing scaled symbol sizes.
 void setResolution(double pDpi)
          Resolution of the device in dots (pixels) per inch.
 void setRotation(double degrees)
          Rotation angle in degrees.
 void setScaleRatio(double scale)
          Scale between FittedBounds and DeviceFrame.
 void setSpatialReferenceByRef(ISpatialReference spatialReference)
          Current spatial reference.
 void setSuppressEvents(boolean suppressEvents)
          Indicates if transformation object suppresses events.
 void setUnits(int unitsCode)
          Units used by world coordinates.
 void setVisibleBounds(IEnvelope bounds)
          Visible extent in world coordinates.
 void setZoomResolution(boolean flag)
          Indicates if resolution is tied to visible bounds.
 IPoint toMapPoint(int x, int y)
          Calculates a point in map coordinates corresponding to the device point.
 double toPoints(double mapDistance)
          Calculates a distance in points (1/72 inch) corresponding to the map distance.
 void transformCoords(_WKSPoint mapPoints, tagPOINT devPoints, int numPoints, int options)
          Transforms a set of points or measurements from device to world space or vice versa.
 void transformRect(IEnvelope mapRect, tagRECT devRect, int options)
          Transforms a rectangle from device to world space or vice versa.
 
Methods inherited from interface com.esri.arcgis.geometry.ITransformation
transformMeasuresFF, transformMeasuresFI, transformMeasuresIF, transformMeasuresII, transformPointsFF, transformPointsFI, transformPointsIF, transformPointsII
 

Method Detail

setBounds

public void setBounds(IEnvelope bounds)
               throws IOException,
                      AutomationException
Full extent in world coordinates.

Supported Platforms

Windows, Solaris, Linux

Parameters:
bounds - An reference to a com.esri.arcgis.geometry.IEnvelope (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getBounds

public IEnvelope getBounds()
                    throws IOException,
                           AutomationException
Full extent in world coordinates.

Supported Platforms

Windows, Solaris, Linux

Remarks

The Bounds property controls the full extent of the display.  IActiveView::FullExtent really stores its full extent here and it has two uses for this property.  In data view, IActiveView calculates the full extent of all the layers and automatically recalculates it whenever the spatial reference changes and when layers are added or removed from the Map.  In layout view, IActiveView stores in FullExtent, the page size (expanded some) and it recalculates this property whenever the page size changes.

Setting the Bounds also sets the VisibleBounds to the same envelope and fires the ITransformEvents::BoundsUpdated and ITransformEvents::VisibleBoundsUpdated events.

Example

>

//IActiveView.FullExtent relates to IDisplayTransformation.Bounds. 
MapControl mapControl; 
IActiveView activeView = mapControl.getActiveView(); 
System.out.println(activeView.getFullExtent().getEnvelope().getXMax()); 
IDisplayTransformation pDisplayTransform = activeView.getScreenDisplay().getDisplayTransformation(); 
System.out.println(pDisplayTransform.getBounds().getXMax());

Returns:
An reference to a com.esri.arcgis.geometry.IEnvelope
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setVisibleBounds

public void setVisibleBounds(IEnvelope bounds)
                      throws IOException,
                             AutomationException
Visible extent in world coordinates.

Supported Platforms

Windows, Solaris, Linux

Parameters:
bounds - An reference to a com.esri.arcgis.geometry.IEnvelope (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getVisibleBounds

public IEnvelope getVisibleBounds()
                           throws IOException,
                                  AutomationException
Visible extent in world coordinates.

Supported Platforms

Windows, Solaris, Linux

Remarks

VisibleBounds controls the visible extent of the display. By setting this property to different extents, you will get zoom in / zoom out effects. The VisibleBounds must fit within the current Bounds.

IActiveView::Extent really stores its value in this property.  In data view, the Extent (VisibleBounds) is modified whenever the spatial reference changes.  Also, the Extent is set the first time a layer is added to the Map.  In layout view, the Extent is initially set to the page size.  In both views, zooming in or out changes the Extent.  The Extent is persisted in map documents.

When the VisibleBounds is set, it is always adjusted to match the aspect ratio the DeviceFrame and this is stored as the FittedBounds.

Setting the Visible Bounds also fires the ITransformEvents::BoundsUpdated and ITransformEvents::VisibleBoundsUpdated events to notify any clients that the bounds have changed.

Returns:
An reference to a com.esri.arcgis.geometry.IEnvelope
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getFittedBounds

public IEnvelope getFittedBounds()
                          throws IOException,
                                 AutomationException
Device frame in world coordinates.

Supported Platforms

Windows, Solaris, Linux

Remarks

The VisibleBounds is adjusted to match the aspect ratio of the DeviceFrame.  This adjusted rectangle is stored in FittedBounds and VisibleBounds stores the actual rectangle specified by the client.  In this way, the FittedBounds is the true visible extent of the display and is a read-only property.

Returns:
An reference to a com.esri.arcgis.geometry.IEnvelope
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getConstrainedBounds

public IEnvelope getConstrainedBounds()
                               throws IOException,
                                      AutomationException
Intersection of Bounds and VisibleBounds.

Supported Platforms

Windows, Solaris, Linux

Remarks

This is usually the same as the FittedBounds unless the display is at full extent and sized so that part of the visible area falls outside of the full extent.

Returns:
An reference to a com.esri.arcgis.geometry.IEnvelope
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setDeviceFrame

public void setDeviceFrame(tagRECT bounds)
                    throws IOException,
                           AutomationException
Visible extent in device coordinates.

Supported Platforms

Windows, Solaris, Linux

Parameters:
bounds - A Structure: com.esri.arcgis.display.tagRECT (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getDeviceFrame

public tagRECT getDeviceFrame()
                       throws IOException,
                              AutomationException
Visible extent in device coordinates.

Supported Platforms

Windows, Solaris, Linux

Remarks

Each DisplayTransformation must have its Bounds, VisibleBounds, and DeviceFrame set.  The DeviceFrame is normally the full extent of the device with the origin equal to (0, 0).  Output can also be directed to some rectangle on the device by specifying the rectangle as the device frame.
For example, if a Map object is not framed, as in the case in ArcMap's data view, the Map uses the Windows API call GetClientRect to get the coordinates of the display and stores them in this property.  This tells the Map where in the window it can draw.
A DeviceFrame can be obtained from IMxDocument::ActiveView::DisplayTransformation::DeviceFrame. It will contain the full extent of the map window. There may be a difference between the values returned in Map view or Layout view due to the possible presence of rulers..
You may also cast a reference to the document's page layout (as found in IMxDocument::PageLayout) into an  IActiveView. The IMxDocument::ActiveView::DisplayTransformation::DeviceFrame will return the same data as above corresponding to the current device extent of the page layout.
Finally if you cast a reference to the map (e.g. from IMxDocument::FocusMap) into an IActiveView. The  IMxDocument::ActiveView::DisplayTransformation::DeviceFrame will return the current device extent of the map.  In Map view it'll be the same as above but in Layout view it'll give back the size of the dataframe in  which the map is drawn.
Setting the DeviceFrame will fire the ITransformEvents::DeviceFrameUpdated event.  Clients typically need to know when the device frame has changed sized so they can redraw.  For example, the ScreenDisplay object listens for this event so that it may update its caches, cause a refresh, and update the scrollbars.
If you are working within ArcMap, no display object's DeviceFrame property should be changed programmatically.

Returns:
A Structure: com.esri.arcgis.display.tagRECT
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setZoomResolution

public void setZoomResolution(boolean flag)
                       throws IOException,
                              AutomationException
Indicates if resolution is tied to visible bounds. If true, zooming in magnifies contents (i.e., zoom in on page).

Supported Platforms

Windows, Solaris, Linux

Parameters:
flag - The flag (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

isZoomResolution

public boolean isZoomResolution()
                         throws IOException,
                                AutomationException
Indicates if resolution is tied to visible bounds. If true, zooming in magnifies contents (i.e., zoom in on page).

Supported Platforms

Windows, Solaris, Linux

Remarks

ZoomResolution is a flag that tells the DisplayTransformation whether or not to automatically adjust the device resolution (pixels per inch) based on the current zoom level.  This is useful when you want to define a page display.  With this kind of display, graphics are drawn at their actual size, i.e., scale is 1:1.  Zooming in really means magnifying the graphics when drawing them to a computer monitor.  When a map page is exported or printed, the zoom level is always 100% and the extent is defined by the page.  Use ZoomResolution to specify this page-style behavior.  With ZoomResolution set to true, the DisplayTransformation monitors the current zoom level.  When the display is zoomed to 100%, a higher effective resolution is calculated.  This has the effect of automatically magnifying all drawing.  The Resolution property always returns the effective resolution.  ScaleRatio always returns 1:1.

Note, when ZoomResolution is true, in order to get the physical device resolution, you must temporarily set ZoomResolution to false, get the Resolution, and then restore the ZoomResolution to true.

To find the current zoom percentage, simply divide the effective resolution by the physical resolution and multiply by 100.  This is what IPageLayout::ZoomPercent does.

If you don't want graphics to scale as you zoom in, set this flag to false.  For example, the Map object sets its DisplayTransformation's ZoomResolution property to false so that the contents of the map are not magnified when you zoom in on them.  The PageLayout sets its DisplayTransformaion's ZoomResolution property to true.

Returns:
The flag
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setResolution

public void setResolution(double pDpi)
                   throws IOException,
                          AutomationException
Resolution of the device in dots (pixels) per inch.

Supported Platforms

Windows, Solaris, Linux

Parameters:
pDpi - The pDpi (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getResolution

public double getResolution()
                     throws IOException,
                            AutomationException
Resolution of the device in dots (pixels) per inch.

Supported Platforms

Windows, Solaris, Linux

Description


 

Remarks

In layout view, when the Page is zoomed 1:1, the resolution equals the device resolution.  When the Page is zoomed to > 100%, the resolution is set higher so that graphics are magnified.

In data view, the Map object always has its resolution set to that of the display.  Graphics are not magnified in this view when you zoom in.

The units are always in pixels per inch.

After setting the resolution, the ITransformEvents::ResolutionUpdated event is fired.

Returns:
The pDpi
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setRotation

public void setRotation(double degrees)
                 throws IOException,
                        AutomationException
Rotation angle in degrees.

Supported Platforms

Windows, Solaris, Linux

Parameters:
degrees - The degrees (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getRotation

public double getRotation()
                   throws IOException,
                          AutomationException
Rotation angle in degrees.

Supported Platforms

Windows, Solaris, Linux

Remarks

This property controls the rotation of the display.  The angle of the rotation is measured in degrees and the rotation occurs around the center of the FittedBounds.

TrackRotate automatically sets this property but if you are using RotateStart / RotateStop, you must do so yourself.  RotateStop provides the final angle rotation that should be used with this property.

Setting a new rotation automatically fires the ITransformEvents::RotationUpdated event.

Returns:
The degrees
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getUnits

public int getUnits()
             throws IOException,
                    AutomationException
Units used by world coordinates.

Supported Platforms

Windows, Solaris, Linux

Remarks

Units is the type of esriUnits used by the DisplayTransformation. For example, the Map object stores its map units in this property and the units are based on the current coordinate system.  See IMap::MapUnits for more details.  Also, the PageLayout's Page object stores its units in this property and it uses inches by default.  See IPage::Units for more details. 

You should not change the units of your Map or Page using this property.  Instead, use the related properties mentioned above.   Although setting the Map's or Page's Units property will set its DisplayTransform Units property, the reverse is not always true.

Setting the Units property fires the ITransformEvents::UnitsUpdated event.

Returns:
A com.esri.arcgis.system.esriUnits constant
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setUnits

public void setUnits(int unitsCode)
              throws IOException,
                     AutomationException
Units used by world coordinates.

Supported Platforms

Windows, Solaris, Linux

Parameters:
unitsCode - A com.esri.arcgis.system.esriUnits constant (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getScaleRatio

public double getScaleRatio()
                     throws IOException,
                            AutomationException
Scale between FittedBounds and DeviceFrame.

Supported Platforms

Windows, Solaris, Linux

Remarks

Several objects that manage a DisplayTransformation, such as the Map object, use this property to control the map scale.  Map scale is the relationship between the dimensions of features on a map and the geographic objects they represent on the earth, commonly expressed as a fraction or a ratio.  A map scale of 1/100,000 or 1:100,000 means that one unit of measure on the map equals 100,000 of the same units on the earth. When you zoom in or out in ArcMap's data view, you are changing this property on the Map's DisplayTransformation .

The Map object has a short-cut (IMap::MapScale) directly to this property on its DisplayTransformation object.

The PageLayout object does not use this property the same way as the Map object.  In ArcMap's layout view, zooming in is akin to using a magnifying glass to zoom in on the page where the map is displayed.  When you zoom in, you are magnifying what is actually going to print.  To get this effect, the PageLayout objects always keeps its ReferenceScale set to zero and its ScaleRatio set to 1:1 (meaning that 1 inch on the screen equals one inch on the printer).

Example

The following java code zooms the focus map to a 1:10,000 scale.

 

MapControl mapControl; 
IActiveView pActiveView = mapControl.getActiveView(); 
IDisplayTransformation pDisplayTransform = pActiveView.getScreenDisplay().getDisplayTransformation() 
pDisplayTransform.setScaleRatio(10000); 
pActiveView.refresh();

Returns:
The scale
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setScaleRatio

public void setScaleRatio(double scale)
                   throws IOException,
                          AutomationException
Scale between FittedBounds and DeviceFrame.

Supported Platforms

Windows, Solaris, Linux

Parameters:
scale - The scale (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getReferenceScale

public double getReferenceScale()
                         throws IOException,
                                AutomationException
Reference scale for computing scaled symbol sizes.

Supported Platforms

Windows, Solaris, Linux

Remarks

All symbols are drawn relative to the scale value set in this property.  By default this value is zero.  Symbol size is true at the reference scale.  When the reference scale is 0, symbols are always drawn at the same size regardless of the map scale (ScaleRatio).  For example, if you set your labels to display with 10 pt font, they will appear as 10 pt text at any map scale.  When the reference scale is greater than 0, symbols are drawn at a size relative to the map scale.  For example, if you set your labels to display with 10 pt font and have a reference scale of 10,000, the labels will appear as 10 pt only at that map scale; as you zoom in, the size of all symbols increases because the size of the symbols is based on the smaller scale.

The Map object has a short-cut (IMap::ReferenceScale) directly to the ReferenceScale property on its DisplayTransformation object.

The PageLayout object does not use ReferenceScale and ScaleRatio the same way as the Map object.  In layout view, zooming in is more like a magnifying glass looking at what is going to print.  When you zoom in, you only magnify what is actually going to print.  To get this effect, the ReferenceScale is always set to zero and the ScaleRatio is always set to 1:1 (i.e., 1 inch on the screen equals one inch on the printer).  In data view however, zooming in or out, changes what gets printed - WYSIWYG (What You See Is What You Get).

Returns:
The scale
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setReferenceScale

public void setReferenceScale(double scale)
                       throws IOException,
                              AutomationException
Reference scale for computing scaled symbol sizes.

Supported Platforms

Windows, Solaris, Linux

Parameters:
scale - The scale (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setSpatialReferenceByRef

public void setSpatialReferenceByRef(ISpatialReference spatialReference)
                              throws IOException,
                                     AutomationException
Current spatial reference.

Parameters:
spatialReference - An reference to a com.esri.arcgis.geometry.ISpatialReference (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

getSpatialReference

public ISpatialReference getSpatialReference()
                                      throws IOException,
                                             AutomationException
Current spatial reference.

Supported Platforms

Windows, Solaris, Linux

Remarks

Use this property to obtain a reference to the transforms coordinate system object.

Returns:
An reference to a com.esri.arcgis.geometry.ISpatialReference
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

isSuppressEvents

public boolean isSuppressEvents()
                         throws IOException,
                                AutomationException
Indicates if transformation object suppresses events.

Supported Platforms

Windows, Solaris, Linux

Remarks

SuppressEvents on IDisplayTransformation prevents events collected under ITransformEvents from being fired.

For example, IScreenDisplay::StartDrawing sets SuppressEvents to TRUE and FinishDrawing sets it back to FALSE, this prevents all transform events from firing during the drawing. 

SuppressEvents is set to FALSE by default.

Returns:
The suppressEvents
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

setSuppressEvents

public void setSuppressEvents(boolean suppressEvents)
                       throws IOException,
                              AutomationException
Indicates if transformation object suppresses events.

Supported Platforms

Windows, Solaris, Linux

Parameters:
suppressEvents - The suppressEvents (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

transformRect

public void transformRect(IEnvelope mapRect,
                          tagRECT devRect,
                          int options)
                   throws IOException,
                          AutomationException
Transforms a rectangle from device to world space or vice versa. Use the flags specified by esriDisplayTransformEnum.

Supported Platforms

Windows, Solaris, Linux

Remarks

TransformRect converts a rectangle from map units to device units or vice versa. The TRANSFORM_TOMAP and TRANSFORM_TODEVICE flags control the direction of the transformation.

Parameters:
mapRect - An reference to a com.esri.arcgis.geometry.IEnvelope (in)
devRect - A Structure: com.esri.arcgis.display.tagRECT (in)
options - The options (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

transformCoords

public void transformCoords(_WKSPoint mapPoints,
                            tagPOINT devPoints,
                            int numPoints,
                            int options)
                     throws IOException,
                            AutomationException
Transforms a set of points or measurements from device to world space or vice versa. Use the flags specified by esriDisplayTransformEnum.

Supported Platforms

Windows, Solaris, Linux

Remarks

TransformCoords converts an array of points from map units to device units or vice versa. The TRANSFORM_TOMAP and TRANSFORM_TODEVICE flags control the direction of the transformation. The TRANSFORM_SIZE and TRANSFORM_POSITION flags specify whether the points are coordinates or sizes.

Parameters:
mapPoints - A Structure: com.esri.arcgis.system._WKSPoint (A com.esri.arcgis.system._WKSPoint COM typedef) (in)
devPoints - A Structure: com.esri.arcgis.display.tagPOINT (in)
numPoints - The numPoints (in)
options - The options (in)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

toMapPoint

public IPoint toMapPoint(int x,
                         int y)
                  throws IOException,
                         AutomationException
Calculates a point in map coordinates corresponding to the device point.

Supported Platforms

Windows, Solaris, Linux

Remarks

ToMapPoint converts an (X,Y) location in device coordinates to real world coordinates (either map units or page units if working with ArcMap's PageLayout ).

Parameters:
x - The x (in)
y - The y (in)
Returns:
An reference to a com.esri.arcgis.geometry.IPoint
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

fromMapPoint

public void fromMapPoint(IPoint mapPoint,
                         int[] x,
                         int[] y)
                  throws IOException,
                         AutomationException
Calculates device coordinates corresponding to the map point.

Supported Platforms

Windows, Solaris, Linux

Remarks

FromMapPoint converts a point in map units to device coordinates.

Parameters:
mapPoint - An reference to a com.esri.arcgis.geometry.IPoint (in)
x - The x (out: use single element array)
y - The y (out: use single element array)
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

toPoints

public double toPoints(double mapDistance)
                throws IOException,
                       AutomationException
Calculates a distance in points (1/72 inch) corresponding to the map distance.

Supported Platforms

Windows, Solaris, Linux

Remarks

Converts the specified map distance into point distance (1/72 inch).

Parameters:
mapDistance - The mapDistance (in)
Returns:
The pointDistance
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.

fromPoints

public double fromPoints(double pointDistance)
                  throws IOException,
                         AutomationException
Calculates a map distance corresponding to a point (1/72) distance.

Supported Platforms

Windows, Solaris, Linux

Remarks

Converts the point distance into map distance.

Parameters:
pointDistance - The pointDistance (in)
Returns:
The mapDistance
Throws:
IOException - If there are communications problems.
AutomationException - If the remote server throws an exception.