Convertendo conjunto de dados de alta precisão no geodatabase de arquivos para baixa precisão usando o ArcObjects?

8

Um conjunto de dados de alta precisão foi carregado de um geodatabase do arquivo no arcsde 9.3.1. A carga de dados foi obtida por copiar / colar no ArcCatalog.

Uma ferramenta customizada (arcobjects) que extrai do conjunto de dados para um geodatabase pessoal de baixa precisão agora está falhando ao tentar criar a classe do recurso de saída.

Não é possível atualizar o geodatabase pessoal com alta precisão, pois todos os outros conjuntos de dados extraídos do sde são de baixa precisão.

O conjunto de dados de alta precisão pode ser rebaixado?

nef001
fonte
você pensou em criar um novo conjunto de dados de baixa precisão e depois importar os dados de alta precisão? Isso pode ser automatizado ainda mais com o construtor de modelos.
Jakub Sisak GeoGraphics
Procurando uma maneira de evitar o recarregamento, pois o conjunto de dados é muito grande, mas pode ser o único.
Nef001 9/11/11
Por precisão, você quer dizer precisão numérica (por exemplo, float16 vs float32) ou detalhes no conjunto de dados?
Paul Hiemstra
Quando a ESRI lançou a versão 9.3, eles introduziram as chamadas referências espaciais de alta precisão e forneceram ferramentas para atualizar os bancos de dados geográficos anteriores à 9.3 para alta precisão. Mas você não pode extrair um conjunto de dados de alta precisão para um geodatabase de baixa precisão.
Nf001
Na verdade, era 9,2
nef001 20/01/12

Respostas:

2

Acabei resolvendo isso modificando o código de extração personalizado para levar em consideração a precisão das referências espaciais de origem e destino.

Código:

        public ISpatialReference createDestinationSpatialRef(IGeoDataset srcDataset, IFeatureWorkspace destinationWorkspace)
        {
            ISpatialReference result = srcDataset.SpatialReference;
            IControlPrecision2 sourceDatasetPrecision = result as IControlPrecision2;

            if (sourceDatasetPrecision.IsHighPrecision)
            {
                if (geodatabaseSupportsHighPrecision(destinationWorkspace))
                {
                    // HP to HP, no conversion
                }
                else
                {
                    IEnvelope extent = srcDataset.Extent;
                    result = ConvertSpatialReferenceFromHighToLowPrecision(result, extent);
                }
            }
            else
            {
                if (geodatabaseSupportsHighPrecision(destinationWorkspace))
                {
                    result = ConvertSpatialReferenceFromLowToHighPrecision(result, -1, 0, 0);
                }
                else
                {
                    // LP to LP, no conversion
                }
            }

            return result;
        }

        public bool geodatabaseSupportsHighPrecision(IFeatureWorkspace fws)
        {
            IGeodatabaseRelease2 release = fws as IGeodatabaseRelease2;
            // geodatabase release is numbered 2.2 at 9.2
            return ((release != null) && ((release.MajorVersion + 7) >= 9) && (release.MinorVersion >= 2));
        }



        /// <summary>
        /// Converts an existing low precision spatial reference and returns a new high precision spatial reference.
        /// </summary>
        /// <param name="lowSpatialReference">An ISpatialReference interface that is the low spatial reference to be converted.</param>
        /// <param name="xyDoubler">A System.Int32 that is the amount of doubling (2^x) based on the input resolution; -1 produces a value close to the default resolution. Example: -1</param>
        /// <param name="mDoubler">A System.Int32 that determines doubling of m-resolution based on input m-resolution; the default is 0. Example: 0</param>
        /// <param name="zDoubler">A System.Int32 that determines doubling of z-resolution based on input z-resolution; default is 0. Example: 0</param>
        /// <returns>An ISpatialReference interface that is the new high precision spatial reference.</returns>
        public ISpatialReference ConvertSpatialReferenceFromLowToHighPrecision(ISpatialReference lowSpatialReference, int xyDoubler, int mDoubler, int zDoubler)
        {
            IControlPrecision2 controlPrecision2 = lowSpatialReference as IControlPrecision2;
            if (controlPrecision2.IsHighPrecision)
                throw new ArgumentException("Expected a low precision spatial reference.", "lowSpatialReference");

            ISpatialReferenceFactory3 spatialReferenceFactory3 = new SpatialReferenceEnvironmentClass();
            ISpatialReference highSpatialReference = spatialReferenceFactory3.ConstructHighPrecisionSpatialReference(lowSpatialReference, xyDoubler, zDoubler, mDoubler);
            return highSpatialReference;
        }


        /// <summary>
        /// Converts an existing high precision spatial reference and returns a new low precision spatial reference.
        /// </summary>
        /// <param name="highSpatialReference">An ISpatialReference interface that is a high precision spatial reference.</param>
        /// <param name="envelope">An IEnvelope that is the area covering the extent of the new low precision spatial reference.</param>
        /// <returns>An ISpatialReference interface that is the new low precision spatial reference.</returns>
        public ISpatialReference ConvertSpatialReferenceFromHighToLowPrecision(ISpatialReference highSpatialReference, IEnvelope envelope)
        {
            IControlPrecision2 controlPrecision2 = highSpatialReference as IControlPrecision2;
            if (!controlPrecision2.IsHighPrecision)
                throw new ArgumentException("Expected a high precision spatial reference.", "highSpatialReference");
            ISpatialReference lowSpatialReference = null;

            ISpatialReferenceFactory3 spatialReferenceFactory3 = new SpatialReferenceEnvironmentClass();
            try
            {
                lowSpatialReference = spatialReferenceFactory3.ConstructLowPrecisionSpatialReference(true, highSpatialReference, envelope);
            }
            catch (System.Runtime.InteropServices.COMException ex)
            {
                if (ex.ErrorCode == -2147220986)
                {
                    lowSpatialReference = spatialReferenceFactory3.ConstructLowPrecisionSpatialReference(false, highSpatialReference, envelope);
                }
            }
            return lowSpatialReference;
        }
nef001
fonte
1

Eu sempre mantenho os dados antigos do Esri ArcTutor para as versões do ArcGIS 9.0 / 9.1 / 9.2. Os bancos de dados geográficos usados ​​são de baixa precisão e sempre posso usá-los como modelo para importação / exportação de dados quando preciso alterar a precisão. Converse com seus representantes da Esri ou dê uma olhada em suas unidades compartilhadas de software. Talvez você encontre alguns dados antigos do ArcTutor ou talvez bancos de dados antigos do ArcGIS que possam servir para esse fim.

Alex Tereshenkov
fonte
-1

Bem, se houver uma casa decimal no número, digamos 10.343243, você pode simplesmente usar a função esquerda ({nome da coluna}, # preservada) no banco de dados de atributos do arcmap. Dando a você 10.343, o que seria menos preciso.

Se o número for 10343243, você poderá usar a mesma função novamente, adicionando apenas zeros novamente ao número após a função inicial. Uma espécie de arredondamento rudimentar.

Faz sentido?

Thad
fonte
Obrigado, mas esta pergunta está relacionada à precisão das referências espaciais da ESRI nos geodatabases.
Nf001