adiwg-mdtranslator 2.13.3 → 2.14.0

data/lib/adiwg/mdtranslator/writers/fgdc/classes/class_localPlanar.rb

@@ -0,0 +1,63 @@
+# FGDC <<Class>> PlanarReference
+# FGDC CSDGM writer output in XML
+
+# History:
+#  Stan Smith 2018-10-09 refactor mdJson projection object
+#  Stan Smith 2018-03-21 original script
+
+require_relative '../fgdc_writer'
+require_relative 'class_mapProjectionTags'
+
+module ADIWG
+   module Mdtranslator
+      module Writers
+         module Fgdc
+
+            class PlanarLocal
+
+               def initialize(xml, hResponseObj)
+                  @xml = xml
+                  @hResponseObj = hResponseObj
+                  @NameSpace = ADIWG::Mdtranslator::Writers::Fgdc
+               end
+
+               def writeXML(hProjection, inContext = nil)
+
+                  # localPLANAR is not the same as localSYSTEM in fgdc
+                  # however they use the same 'local' object
+                  # local system sets projectionIdentifier.identifier = 'localSystem'
+                  # local planar sets projectionIdentifier.identifier = 'localPlanar'
+
+                  # classes used
+                  classTags = MapProjectionTags.new(@xml, @hResponseObj)
+
+                  outContext = 'local planar'
+                  outContext = inContext + ' '  + outContext unless inContext.nil?
+
+                  hProjectionId = hProjection[:projectionIdentifier]
+                  hLocal = hProjection[:local]
+
+                  if hLocal.empty?
+                     @NameSpace.issueError(470, outContext)
+                     return
+                  end
+
+                  # planar 4.1.2.3 (localp) - local planar
+                  if hProjectionId[:identifier] == 'localPlanar'
+                     hProjectionId[:name] = nil unless hProjectionId.has_key?(:name)
+                     if hProjectionId[:name].nil?
+                        hProjectionId[:name] = 'Local Planar Coordinate System Fixed to Earth'
+                     end
+                     @xml.tag!('localp') do
+                        classTags.write_localDesc(hProjection, outContext)
+                        classTags.write_localGeoInfo(hProjection, outContext)
+                     end
+                  end
+
+               end # writeXML
+            end # PlanarReference
+
+         end
+      end
+   end
+end

data/lib/adiwg/mdtranslator/writers/fgdc/classes/class_localSystem.rb

@@ -2,6 +2,7 @@
 # FGDC CSDGM writer output in XML
 
 # History:
+#  Stan Smith 2018-10-09 refactor mdJson projection object
 #  Stan Smith 2018-03-20 refactored error and warning messaging
 #  Stan Smith 2018-01-15 original script
 
@@ -14,37 +15,51 @@ module ADIWG
 
             class LocalSystem
 
-               def initialize(xml, hResponseObj)
+               def initialize(xml, hResponseObj, inContext = nil)
                   @xml = xml
                   @hResponseObj = hResponseObj
                   @NameSpace = ADIWG::Mdtranslator::Writers::Fgdc
                end
 
-               def writeXML(hProjection)
+               def writeXML(hProjection, inContext = nil)
 
                   # localSYSTEM is not the same as localPLANAR in fgdc
-                  # however the same projection parameters are used in mdJson to save info
-                  # local system sets projection = 'localSystem'
-                  # local planar sets projection = 'localPlanar'
+                  # however they use the same 'local' object
+                  # local system sets projectionIdentifier.identifier = 'localSystem'
+                  # local planar sets projectionIdentifier.identifier = 'localPlanar'
 
-                  if hProjection[:projectionName].nil?
-                     hProjection[:projectionName] = 'local coordinate system not aligned with surface of earth'
+                  hProjectionId = hProjection[:projectionIdentifier]
+                  hLocal = hProjection[:local]
+
+                  outContext = 'local system'
+                  outContext = inContext + ' '  + outContext unless inContext.nil?
+
+                  if hLocal.empty?
+                     @NameSpace.issueError(250, outContext)
+                     return
+                  end
+
+                  if hProjectionId[:identifier] == 'localSystem'
+                     hProjectionId[:name] = nil unless hProjectionId.has_key?(:name)
+                     if hProjectionId[:name].nil?
+                        hProjectionId[:name] = 'Local Coordinate System'
+                     end
                   end
 
                   # local system 4.1.3.1 (localdes) - local coordinate system description (required)
-                  unless hProjection[:localPlanarDescription].nil?
-                     @xml.tag!('localdes', hProjection[:localPlanarDescription])
+                  unless hLocal[:description].nil?
+                     @xml.tag!('localdes', hLocal[:description])
                   end
-                  if hProjection[:localPlanarDescription].nil?
-                     @NameSpace.issueError(250, hProjection[:projectionName])
+                  if hLocal[:description].nil?
+                     @NameSpace.issueError(251, outContext)
                   end
 
                   # local system 4.1.3.2 (localgeo) - local coordinate system georeference information (required)
-                  unless hProjection[:localPlanarGeoreference].nil?
-                     @xml.tag!('localgeo', hProjection[:localPlanarGeoreference])
+                  unless hLocal[:georeference].nil?
+                     @xml.tag!('localgeo', hLocal[:georeference])
                   end
-                  if hProjection[:localPlanarGeoreference].nil?
-                     @NameSpace.issueError(251, hProjection[:projectionName])
+                  if hLocal[:georeference].nil?
+                     @NameSpace.issueError(252, outContext)
                   end
 
                end # writeXML

data/lib/adiwg/mdtranslator/writers/fgdc/classes/class_mapProjectionTags.rb

@@ -2,6 +2,7 @@
 # FGDC CSDGM writer output in XML
 
 # History:
+#  Stan Smith 2018-10-09 refactor mdJson projection object
 #  Stan Smith 2018-03-20 refactored error and warning messaging
 #  Stan Smith 2018-01-02 original script
 
@@ -20,20 +21,36 @@ module ADIWG
                   @NameSpace = ADIWG::Mdtranslator::Writers::Fgdc
                end
 
+               def outContext(inContext, hIdentifier = {})
+                  outContext = hIdentifier.empty? ? nil : hIdentifier[:projectionIdentifier][:identifier]
+                  return nil if inContext.nil? && outContext.nil?
+                  return inContext if outContext.nil?
+                  return outContext if inContext.nil?
+                  return inContext + ' ' + outContext
+               end
+
+               def outContextGrid(inContext, hIdentifier = {})
+                  outContext = hIdentifier.empty? ? nil : hIdentifier[:gridIdentifier][:identifier]
+                  return nil if inContext.nil? && outContext.nil?
+                  return inContext if outContext.nil?
+                  return outContext if inContext.nil?
+                  return inContext + ' ' + outContext
+               end
+
                # map projection 4.1.2.1.1 (mapprojn) - projection name (required)
-               def write_name(projectionName)
+               def write_name(projectionName, inContext = nil)
                   unless projectionName.nil?
                      @xml.tag!('mapprojn', projectionName)
                   end
                   if projectionName.nil?
-                     @NameSpace.issueWarning(280, 'mapprojn')
+                     @NameSpace.issueWarning(280, 'mapprojn', inContext)
                   end
                end
 
                # map projection 4.1.2.2.1 (gridsysn) - grid system name
-               def write_gridName(gridSystem)
+               def write_gridName(gridSystem, inContext = nil)
                   unless gridSystem.nil?
-                     @xml.tag!('gridsysn', gridSystem)
+                     @xml.tag!('gridsysn', gridSystem, inContext)
                   end
                   if gridSystem.nil? && @hResponseObj[:writerShowTag]
                      @xml.tag!('gridsysn')
@@ -42,23 +59,23 @@ module ADIWG
 
                # map projection (feast) - false easting (required)
                # map projection (fnorth) - false northing (required)
-               def write_falseNE(hProjection)
+               def write_falseNE(hProjection, inContext = nil)
                   unless hProjection[:falseEasting].nil?
                      @xml.tag!('feast', hProjection[:falseEasting].to_s)
                   end
                   if hProjection[:falseEasting].nil?
-                     @NameSpace.issueError(281, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(281, outContext(inContext, hProjection))
                   end
                   unless hProjection[:falseNorthing].nil?
                      @xml.tag!('fnorth', hProjection[:falseNorthing].to_s)
                   end
                   if hProjection[:falseNorthing].nil?
-                     @NameSpace.issueError(282, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(282, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (stdparll) - standard parallel (at least one required)
-               def write_standParallel(hProjection)
+               def write_standParallel(hProjection, inContext = nil)
                   haveParallel = false
                   unless hProjection[:standardParallel1].nil?
                      @xml.tag!('stdparll', hProjection[:standardParallel1].to_s)
@@ -69,276 +86,314 @@ module ADIWG
                      haveParallel = true
                   end
                   unless haveParallel
-                     @NameSpace.issueError(283, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(283, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (longcm) - longitude of central meridian (required)
-               def write_longCM(hProjection)
+               def write_longCM(hProjection, inContext = nil)
                   unless hProjection[:longitudeOfCentralMeridian].nil?
                      @xml.tag!('longcm', hProjection[:longitudeOfCentralMeridian].to_s)
                   end
                   if hProjection[:longitudeOfCentralMeridian].nil?
-                     @NameSpace.issueError(284, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(284, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (latprjo) - latitude of projection origin (required)
-               def write_latPO(hProjection)
+               def write_latPO(hProjection, inContext = nil)
                   unless hProjection[:latitudeOfProjectionOrigin].nil?
                      @xml.tag!('latprjo', hProjection[:latitudeOfProjectionOrigin].to_s)
                   end
                   if hProjection[:latitudeOfProjectionOrigin].nil?
-                     @NameSpace.issueError(285, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(285, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (heightpt) - height of perspective point above surface (required)
-               def write_heightPP(hProjection)
+               def write_heightPP(hProjection, inContext = nil)
                   unless hProjection[:heightOfProspectivePointAboveSurface].nil?
                      @xml.tag!('heightpt', hProjection[:heightOfProspectivePointAboveSurface].to_s)
                   end
                   if hProjection[:heightOfProspectivePointAboveSurface].nil?
-                     @NameSpace.issueError(286, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(286, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (longpc) - longitude of projection center (required)
-               def write_longPC(hProjection)
+               def write_longPC(hProjection, inContext = nil)
                   unless hProjection[:longitudeOfProjectionCenter].nil?
                      @xml.tag!('longpc', hProjection[:longitudeOfProjectionCenter].to_s)
                   end
                   if hProjection[:longitudeOfProjectionCenter].nil?
-                     @NameSpace.issueError(287, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(287, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (latprjc) - latitude of projection center (required)
-               def write_latPC(hProjection)
+               def write_latPC(hProjection, inContext = nil)
                   unless hProjection[:latitudeOfProjectionCenter].nil?
                      @xml.tag!('latprjc', hProjection[:latitudeOfProjectionCenter].to_s)
                   end
                   if hProjection[:latitudeOfProjectionCenter].nil?
-                     @NameSpace.issueError(288, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(288, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (sfequat) - scale factor at equator (required)
-               def write_scaleFactorE(hProjection)
+               def write_scaleFactorE(hProjection, inContext = nil)
                   unless hProjection[:scaleFactorAtEquator].nil?
                      @xml.tag!('sfequat', hProjection[:scaleFactorAtEquator].to_s)
                   end
                   if hProjection[:scaleFactorAtEquator].nil?
-                     @NameSpace.issueError(289, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(289, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (sfctrlin) - scale factor at center line (required)
-               def write_scaleFactorCL(hProjection)
+               def write_scaleFactorCL(hProjection, inContext = nil)
                   unless hProjection[:scaleFactorAtCenterLine].nil?
                      @xml.tag!('sfctrlin', hProjection[:scaleFactorAtCenterLine].to_s)
                   end
                   if hProjection[:scaleFactorAtCenterLine].nil?
-                     @NameSpace.issueError(290, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(290, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (sfprjorg) - scale factor at projection origin (required)
-               def write_scaleFactorPO(hProjection)
+               def write_scaleFactorPO(hProjection, inContext = nil)
                   unless hProjection[:scaleFactorAtProjectionOrigin].nil?
                      @xml.tag!('sfprjorg', hProjection[:scaleFactorAtProjectionOrigin].to_s)
                   end
                   if hProjection[:scaleFactorAtProjectionOrigin].nil?
-                     @NameSpace.issueError(291, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(291, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (sfctrmer) - scale factor at central meridian (required)
-               def write_scaleFactorCM(hProjection)
+               def write_scaleFactorCM(hProjection, inContext = nil)
                   unless hProjection[:scaleFactorAtCentralMeridian].nil?
                      @xml.tag!('sfctrmer', hProjection[:scaleFactorAtCentralMeridian].to_s)
                   end
                   if hProjection[:scaleFactorAtCentralMeridian].nil?
-                     @NameSpace.issueError(292, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(292, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (obqlazim) - oblique line azimuth (required)
-               def write_obliqueLineAzimuth(hProjection)
-                  haveLA = true
-                  haveLA = false if hProjection[:azimuthAngle].nil?
-                  haveLA = false if hProjection[:azimuthMeasurePointLongitude].nil?
+               def write_obliqueLineAzimuth(hProjection, inContext = nil)
+                  haveLA = false
+                  haveLA = true unless hProjection[:azimuthAngle].nil?
+                  haveLA = true unless hProjection[:azimuthMeasurePointLongitude].nil?
                   if haveLA
                      @xml.tag!('obqlazim') do
                         unless hProjection[:azimuthAngle].nil?
                            @xml.tag!('azimangl', hProjection[:azimuthAngle].to_s)
                         end
                         if hProjection[:azimuthAngle].nil?
-                           @NameSpace.issueError(293, "#{hProjection[:projectionName]} projection")
+                           @NameSpace.issueError(293, outContext(inContext, hProjection))
                         end
                         unless hProjection[:azimuthMeasurePointLongitude].nil?
                            @xml.tag!('azimptl', hProjection[:azimuthMeasurePointLongitude].to_s)
                         end
                         if hProjection[:azimuthMeasurePointLongitude].nil?
-                           @NameSpace.issueError(294, "#{hProjection[:projectionName]} projection")
+                           @NameSpace.issueError(294, outContext(inContext, hProjection))
                         end
                      end
                   end
                   unless haveLA
-                     @NameSpace.issueError(295, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(295, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (obqlpt) - oblique line point (required)
-               def write_obliqueLinePoint(hLinePt)
-                  unless hLinePt[:azimuthLineLatitude].nil?
-                     @xml.tag!('obqllat', hLinePt[:azimuthLineLatitude])
-                  end
-                  if hLinePt[:azimuthLineLatitude].nil?
-                     @NameSpace.issueError(296, 'oblique line-point projection')
-                  end
-                  unless hLinePt[:azimuthLineLongitude].nil?
-                     @xml.tag!('obqllong', hLinePt[:azimuthLineLongitude])
+               def write_obliqueLinePoint(hProjection, inContext = nil)
+                  aLinePoint = hProjection[:obliqueLinePoints]
+                  @xml.tag!('obqlpt') do
+                     aLinePoint.each do |hLinePt|
+                        unless hLinePt[:obliqueLineLatitude].nil?
+                           @xml.tag!('obqllat', hLinePt[:obliqueLineLatitude])
+                        end
+                        if hLinePt[:obliqueLineLatitude].nil?
+                           @NameSpace.issueError(296, outContext(inContext, hProjection))
+                        end
+                        unless hLinePt[:obliqueLineLongitude].nil?
+                           @xml.tag!('obqllong', hLinePt[:obliqueLineLongitude])
+                        end
+                        if hLinePt[:obliqueLineLongitude].nil?
+                           @NameSpace.issueError(297, outContext(inContext, hProjection))
+                        end
+                     end
                   end
-                  if hLinePt[:azimuthLineLongitude].nil?
-                     @NameSpace.issueError(297, 'oblique line-point projection')
+                  unless aLinePoint.length == 2
+                     @NameSpace.issueError(302, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (svlong) - straight vertical longitude from pole (required)
-               def write_straightFromPole(hProjection)
+               def write_straightFromPole(hProjection, inContext = nil)
                   unless hProjection[:straightVerticalLongitudeFromPole].nil?
                      @xml.tag!('svlong', hProjection[:straightVerticalLongitudeFromPole].to_s)
                   end
                   if hProjection[:straightVerticalLongitudeFromPole].nil?
-                     @NameSpace.issueError(298, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(298, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (landsat) - landsat number (required)
-               def write_landsat(hProjection)
+               def write_landsat(hProjection, inContext = nil)
                   unless hProjection[:landsatNumber].nil?
                      @xml.tag!('landsat', hProjection[:landsatNumber].to_s)
                   end
                   if hProjection[:landsatNumber].nil?
-                     @NameSpace.issueError(299, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(299, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (pathnum) - landsat path (required)
-               def write_landsatPath(hProjection)
+               def write_landsatPath(hProjection, inContext = nil)
                   unless hProjection[:landsatPath].nil?
                      @xml.tag!('pathnum', hProjection[:landsatPath].to_s)
                   end
                   if hProjection[:landsatPath].nil?
-                     @NameSpace.issueError(300, "#{hProjection[:projectionName]} projection")
+                     @NameSpace.issueError(300, outContext(inContext, hProjection))
+                  end
+               end
+
+               # grid coordinate system (localpd) - local planar description (required)
+               def write_localDesc(hProjection, inContext)
+                  hLocal = hProjection[:local]
+                  unless hLocal.empty?
+                     @xml.tag!('localpd', hLocal[:description])
+                  end
+                  if hLocal[:description].nil?
+                     @NameSpace.issueError(471, outContext(inContext))
+                  end
+               end
+
+               # grid coordinate system (localpgi) - local planar georeference information (required)
+               def write_localGeoInfo(hProjection, inContext)
+                  hLocal = hProjection[:local]
+                  unless hLocal.empty?
+                     @xml.tag!('localpgi', hLocal[:georeference])
+                  end
+                  if hLocal[:georeference].nil?
+                     @NameSpace.issueError(472, outContext(inContext))
                   end
                end
 
                # map projection (otherprj) - other projection description (required)
-               def write_otherProjection(hProjection)
-                  unless hProjection[:otherProjectionDescription].nil?
-                     @xml.tag!('otherprj', hProjection[:otherProjectionDescription])
+               def write_otherProjection(hProjection, inContext = nil)
+                  unless hProjection[:projectionIdentifier][:description].nil?
+                     @xml.tag!('otherprj', hProjection[:projectionIdentifier][:description])
                   end
-                  if hProjection[:otherProjectionDescription].nil?
-                     @NameSpace.issueError(301, "#{hProjection[:projectionName]} projection")
+                  if hProjection[:projectionIdentifier][:description].nil?
+                     @NameSpace.issueError(301, outContext(inContext, hProjection))
                   end
                end
 
                # map projection (mapprojp) - other projection description (required)
-               def write_allParams(hProjection)
-                  # save current writer error state
-                  writerPass = @hResponseObj[:writerPass]
-                  writerMessages = @hResponseObj[:writerMessages]
+               def write_allParams(hProjection, inContext)
 
                   # write all parameters
-                  write_falseNE(hProjection)
-                  write_standParallel(hProjection)
-                  write_longCM(hProjection)
-                  write_latPO(hProjection)
-                  write_heightPP(hProjection)
-                  write_longPC(hProjection)
-                  write_latPC(hProjection)
-                  write_scaleFactorE(hProjection)
-                  write_scaleFactorCL(hProjection)
-                  write_scaleFactorPO(hProjection)
-                  write_scaleFactorCM(hProjection)
-                  write_obliqueLineAzimuth(hProjection)
+                  unless hProjection[:falseNorthing].nil?
+                     write_falseNE(hProjection, inContext)
+                  end
+                  unless hProjection[:standardParallel1].nil?
+                     write_standParallel(hProjection, inContext)
+                  end
+                  unless hProjection[:longitudeOfCentralMeridian].nil?
+                     write_longCM(hProjection, inContext)
+                  end
+                  unless hProjection[:latitudeOfProjectionOrigin].nil?
+                     write_latPO(hProjection, inContext)
+                  end
+                  unless hProjection[:heightOfProspectivePointAboveSurface].nil?
+                     write_heightPP(hProjection, inContext)
+                  end
+                  unless hProjection[:longitudeOfProjectionCenter].nil?
+                     write_longPC(hProjection, inContext)
+                  end
+                  unless hProjection[:latitudeOfProjectionCenter].nil?
+                     write_latPC(hProjection, inContext)
+                  end
+                  unless hProjection[:scaleFactorAtEquator].nil?
+                     write_scaleFactorE(hProjection, inContext)
+                  end
+                  unless hProjection[:scaleFactorAtCenterLine].nil?
+                     write_scaleFactorCL(hProjection, inContext)
+                  end
+                  unless hProjection[:scaleFactorAtProjectionOrigin].nil?
+                     write_scaleFactorPO(hProjection, inContext)
+                  end
+                  unless hProjection[:scaleFactorAtCentralMeridian].nil?
+                     write_scaleFactorCM(hProjection, inContext)
+                  end
+                  unless hProjection[:azimuthAngle].nil?
+                     write_obliqueLineAzimuth(hProjection, inContext)
+                  end
                   unless hProjection[:obliqueLinePoints].empty?
-                     @xml.tag!('obqlpt') do
-                        hProjection[:obliqueLinePoints].each do |hLinePt|
-                           write_obliqueLinePoint(hLinePt)
-                        end
-                     end
+                     write_obliqueLinePoint(hProjection, inContext)
+                  end
+                  unless hProjection[:straightVerticalLongitudeFromPole].nil?
+                     write_straightFromPole(hProjection, inContext)
+                  end
+                  unless hProjection[:landsatNumber].nil?
+                     write_landsat(hProjection, inContext)
+                  end
+                  unless hProjection[:landsatPath].nil?
+                     write_landsatPath(hProjection, inContext)
                   end
-                  write_straightFromPole(hProjection)
-                  write_landsat(hProjection)
-                  write_landsatPath(hProjection)
-                  write_otherProjection(hProjection)
-
-                  # restore writer error state
-                  @hResponseObj[:writerPass] = writerPass
-                  @hResponseObj[:writerMessages] = writerMessages
 
                end
 
                # grid coordinate system (utmzone) - universal transverse mercator zone (required)
-               def write_utmZone(hProjection)
+               def write_utmZone(hProjection, inContext)
                   unless hProjection[:gridZone].nil?
                      @xml.tag!('utmzone', hProjection[:gridZone])
                   end
                   if hProjection[:gridZone].nil?
-                     @NameSpace.issueError(310, 'grid system')
+                     @NameSpace.issueError(310, outContextGrid(inContext, hProjection))
                   end
                end
 
                # grid coordinate system (upszone) - universal polar stereographic zone (required)
-               def write_upsZone(hProjection)
+               def write_upsZone(hProjection, inContext)
                   unless hProjection[:gridZone].nil?
                      @xml.tag!('upszone', hProjection[:gridZone])
                   end
                   if hProjection[:gridZone].nil?
-                     @NameSpace.issueError(311, 'grid system')
+                     @NameSpace.issueError(311, outContextGrid(inContext, hProjection))
                   end
                end
 
                # grid coordinate system (spcszone) - state plane coordinate system zone (required)
-               def write_spcsZone(hProjection)
+               def write_spcsZone(hProjection, inContext)
                   unless hProjection[:gridZone].nil?
                      @xml.tag!('spcszone', hProjection[:gridZone])
                   end
                   if hProjection[:gridZone].nil?
-                     @NameSpace.issueError(312, 'grid system')
+                     @NameSpace.issueError(312, outContextGrid(inContext, hProjection))
                   end
                end
 
                # grid coordinate system (arczone) - equal arc-second coordinate system zone (required)
-               def write_arcZone(hProjection)
+               def write_arcZone(hProjection, inContext)
                   unless hProjection[:gridZone].nil?
                      @xml.tag!('arczone', hProjection[:gridZone])
                   end
                   if hProjection[:gridZone].nil?
-                     @NameSpace.issueError(313, 'grid system')
+                     @NameSpace.issueError(313, outContextGrid(inContext, hProjection))
                   end
                end
 
-               # grid coordinate system (localpd) - local planar description (required)
-               def write_localDesc(hProjection)
-                  unless hProjection[:localPlanarDescription].nil?
-                     @xml.tag!('localpd', hProjection[:localPlanarDescription])
-                  end
-                  if hProjection[:localPlanarDescription].nil?
-                     @NameSpace.issueError(302, "#{hProjection[:projectionName]}")
-                  end
-               end
-
-               # grid coordinate system (localpgi) - local planar georeference information (required)
-               def write_localGeoInfo(hProjection)
-                  unless hProjection[:localPlanarGeoreference].nil?
-                     @xml.tag!('localpgi', hProjection[:localPlanarGeoreference])
+               # map projection (othergrd) - other grid description (required)
+               def write_otherGrid(hProjection, inContext = nil)
+                  unless hProjection[:gridIdentifier][:description].nil?
+                     @xml.tag!('othergrd', hProjection[:gridIdentifier][:description])
                   end
-                  if hProjection[:localPlanarGeoreference].nil?
-                     @NameSpace.issueError(303, "#{hProjection[:projectionName]}")
+                  if hProjection[:gridIdentifier][:description].nil?
+                     @NameSpace.issueError(314, outContext(inContext, hProjection))
                   end
                end