Hoje estou trabalhando em um projeto comp

lexo com requisitos, bem, acima da média. Nosso usuário é bastante exigente e com razão. Há uns milhares de posts atrás, falei sobre class extensions aqui e aqui.

Class extensions são uma forma muito poderosa se customizar o comportamente básico do ArcGIS, em qualquer versão ou em qualquer ambiente. Elas funcionam em Java, C#, com server, em desktop e com ArcEngine. São praticamente universais para os produtos ESRI. Além disso, são relativamente fáceis de implementar e não possuem muitos requisitos.

Só possui um único requisito de deploy:

• O código desenvolvido necessita estar na máquina (cliente, server, ou qualquer coisa que o valha - e claro, não o código, mas sim os binários que foram gerados);

E uma limitação:

• Uma tabela ou feature class, só pode ter uma e somente uma, class extension.

Tudo bem até aí. Nos primeiros posts falei de class extensions que poderiam herdar funcionalidade de outras class extensions. Mas o código cresce rapidamente e se temos que cuidar de um ou mais comportamentos na mesma class extension, isso pode ficar simplesmente insuportável para o desenvolvedor.

Uma outra maneira de se fazer as coisas é através de composição. Ao invés de criarmos uma hierarquia complexa de class extensions, na qual a CE mais específica deriva da CE mais geral, foi necessário construir uma class extension que fosse extensível, mas sem recompilar o código e sem afetar o funcionamento básico de outras funcionalidades.

Uma das partes do problema é que elas são configuráveis através de um conjunto de dados, o objeto IPropertySet. Acessá-lo não é difícil, mas traz uma chateação à mais para o desenvoledor.

Bem, o que fizemos: abstraimos toda a funcionalidade da class extension. A única class extensions verdadeira que temos contém uma referência à um grupo de classes que implementam as funcionalidades, mas não são registradas na classe. Isso nos permite adicionar e ou remover uma parte da funcionalidade sem afetar as outras.

Temos basicamente três objetos principais:

• Uma class extension geral (a quem chamamos de polimórfica);
• Um ClassExtensionContainer (que segura referências à outras classes que fazem todo o trabalho);
• Uma fábrica de ClassExtensionContainer. Como não queremos que a nossa class extension determine quais serão as funcionalidades que ela executará, não podemos deixar à cargo da mesma a criação do nosso container.

Agora, por que separar esses caras assim? Bem, queremos que nossa class extension (que será registrada com nossa feature class ou tabela) consiga ser executada, independente do que existe no container. E não queremos que ela crie o container, pois bem, existem várias maneiras de criá-lo, e.g. chamada direta, lendo um arquivo texto ou até mesmo acessando um banco de dados. Por isso criamos a fábrica. Se quisermos mudar a maneira de como criar o container, só mudamos a fábrica e não nosso projeto completo.

Bem, o projeto é mais ou menos assim:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using Core.Model;
using ESRI.ArcGIS.ADF.CATIDs;
using ESRI.ArcGIS.Editor;
using ESRI.ArcGIS.esriSystem;
using ESRI.ArcGIS.Geodatabase;
using log4net;
using ILog = log4net.ILog;

namespace Core.Extension.ModelExtension
{
    [Guid("32f7294c-eaf3-4df1-90aa-03e2828f305e")]
    [ClassInterface(ClassInterfaceType.None)]
    [ProgId("Core.Extension.ModelExtension.PolymorphicExtension")]
    public class PolymorphicExtension :
        BaseClasse,
        IInterfaceCustomizadaQueImplementaInterfacesESRI, // IClassExtension, IObjectClass, etc.
        IObjectInspector
    {

        // código de registro com removido 

        private IClassExtensionContainer _container;

        public override void Initialize()
        {
            var dataset = (IDataset)_helper.Class;
            _elementType = DetermineElementType(dataset);
           // inicializamos o container.
            _container = ClassExtensionContainerFactory.CreateContainer(_elementType);

            // inicializamos outras class extensions, que talvez precisem de serem inicializadas!
            foreach(var ext in _container.Extensions)
            {
                ext.Init(_helper, null);
            }
        }

        public override void Shutdown()
        {

        }

        public override void OnChange(IObject obj)
        {
            foreach (var ext in _container.Extensions)
            {
                _log.InfoFormat("Disparando OnChange de {0}", ext.ExtensionName);
                ext.OnChange(obj);
            }
        }

        public override void OnCreate(IObject obj)
        {
            foreach(var ext in _container.Extensions)
            {
                _log.InfoFormat("Disparando OnCreate de {0}", ext.ExtensionName);
                ext.OnCreate(obj);
            }
        }

        public override void OnDelete(IObject obj)
        {
            foreach(var ext in _container.Extensions)
            {
                _log.InfoFormat("Disparando OnDelete de {0}", ExtensionName);
                ext.OnDelete(obj);
            }
        }

        public override string ValidateField(IRow row, string fieldName)
        {
            _log.InfoFormat("Validando campo {0}",fieldName);

            var sb = new StringBuilder();

            foreach (var ext in _container.Extensions)
            {
                try
                {
                    _log.InfoFormat("Validando extensão {0}", ExtensionName);
                    sb.AppendLine(ext.ValidateField(row, fieldName));
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Ocorreu um erro ao tentar validar o campo {0} em {1}", fieldName, ExtensionName);
                    _log.Error(ex.Message, ex);
                    continue;
                }
            }

            return sb.ToString();
        }

        public override string ValidateRow(IRow row)
        {
            _log.Info("Validando linha");

            var sb = new StringBuilder();

            foreach (var ext in _container.Extensions)
            {
                try
                {
                    _log.InfoFormat("Validando extensão {0}", ExtensionName);
                    sb.AppendLine(ext.ValidateRow(row));
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Ocorreu um erro ao tentar validar a linha em {0}", ExtensionName);
                    _log.Error(ex.Message, ex);
                    continue;
                }
            }

            return sb.ToString();
        }

        public void Inspect(IEnumRow objects, IEditor editor)
        {
            _container.CustomInspector.Inspect(objects, editor);
        }

        public void Clear()
        {
            _container.CustomInspector.Clear();
        }

        public void Copy(IRow srcRow)
        {
            _container.CustomInspector.Copy(srcRow);
        }

        public int HWND
        {
            get { return _container.CustomInspector.HWND; }
        }
    }
}

A principal sacada neste caso, é o nosso container. Ele contém uma referência para uma interface customizada, que implementa a parte principal dos comportamentos, que são:

• IObjectClassExtension
• IClassExtension
• IFeatureExtension
• IObjectClassEvents
• IObjectClassValidation
• IObjectInspector (este cara aqui é para customizarmos o painel de edição default do ArcGIS! nosso container também contém ele!)

Estas interfaces da ESRI que vão segurar toda nossas funcionalidades, quaisquer que sejam. Segue nosso container:

public interface IClassExtensionContainer
 {
 List<ICustomClassExtension> Extensions { get; }
 IObjectInspector AirspaceInspector { get; }
 }

Ele é só isso. A mágica fica na fábrica, que preenche este camarada e passa ele para nossa extensão de verdade. Depois que o container foi inicializado, durante o método Init() da classe principal - a própria CE inicializa as outras;

Este padrão é seguido nos outros métodos. Ela delega para as classes que contém funcionalidade as ações que devem ser executadas. Desta maneira conseguimos múltiplos comportamentos customizados e uma facilidade enorme para adicionar ou removê-los.

Por isso o nome de Cascading Class Extension. Na realidade, temos única class extension que cuida de tudo para nós, cascateando todo o comportamento interessante para nós.

O que acharam? ArcObjects não é complicado, é cheio de manhas. Depois que as conhecemos, fica muito fácil!

Ah, em nota: tenho desenvolvido algum código baseado em ArcObjects que vou disponibilizar em breve. Assim que disponibilizar, você poderá ver esta implementação acima, completa!

Abraços

George R. C. Silva

Related posts:

1. ArcObjects e Class Extensions #2
2. ArcObjects e Class Extensions #1
3. Hello World, ArcGIS style!

Depois de um tempinho apareço denovo! Hoje quero falar um pouco sobre padrões de projeto (Design Patterns) e a como acessar dados via ArcObjects.

Como vocês sabem, os objetos da ESRI são bastante chatinhos de se trabalhar. Eles tem peculiaridades incríveis e se nos esquecermos delas vamos acabar nos dando mal! A grande questão estamos falando de uma biblioteca enorme e temos, com certeza, algumas interfaces centrais. Duas delas, com certeza são IObject e IObjectClass.

Em termos simples, IObject é uma linha de uma tabela, enquanto IObjectClass representa a tabela como um todo. Quase tudo que armazenamos dentro de um geodatabase é uma IObjectClass e seus filhotes, um IObject – até mesmo rasters.

Mas porque é tão difícil acessar e manipular as informações utilizando a API da ESRI? Bem, não é que é difícil. Para coisas pequenas é bastante tranquilo e simples, exemplo:

public class LeitorValores
{
	// esta classe lê os valores de uma tabela
	// ou feature class e os escreve na console.

	private IWorkspace _Workspace;
	private ITable _Tabela;

	public LeitorValores(IWorkspace workspace,string nomeTabela)
	{
		_Workspace = workspace;
		_Tabela = ((IFeatureWorkspace)workspace).OpenTable(nomeTabela);
	}

	public LerValores()
	{
		// poderiamos ter configurado o filtro como parâmetro

		IQueryFilter filter = new QueryFilterClass();
		filter.WhereClause = "";
		// a query está vazia, pois queremos ler e escrever todos os valores;

		ICursor cursor = _Tabela.Search(filter,true);

                // aqui poderíamos ter utilizado a interface mãe: IObject
                // IObject tempObject = null;		

                IRow tempRow = null;
		// tempObjectt = cursro.NextRow() as IObject
		while ((tempRow = cursor.NextRow()) != null)
		{
			for (int i = 0; i <= tempRow.Fields.FieldCount -1; i++)
			{
				Console.Write(tempRow.get_Value(i).ToString());
				Console.Write("\t");
			}
			Console.WriteLine();
		}
	}
}

É um classe bem simples, mas repare no seguinte fluxo:

1. Construímos uma query vazia (equivalente à “SELECT * FROM TABLE”);
2. Pedimos um ICursor (o cursor é um objeto que lhe permite navegar por linhas da tabela de forma ordenada, forward only, ou seja, só permite Next, e não Previous);
3. Iteramos pelo cursor, pegando cada linha da tabela e percorrendo suas colunas, uma à uma para buscar seu valor;

Note que só temos uma forma de ler o valor de uma coluna: utilizando o método get_Value(int i);

Para exemplos simples, não existem problemas, mas porém quando estamos falando de um sistema maior e que necessita de ser bem estruturado, como sabemos em nossos arquivos de código que o campo n é necessariamente, NomeRodovia, por exemplo? Se mudarem o modelo (por qualquer motivo) nosso código vai falhar (ou pior, vai funcionar e vai começar à nos passar valores errados – de coluna).

Deve existir um jeito mais fácil! Bem, existem algumas alternativas:

• Passar todo o acesso à dados para um framework ORM (Object Relational Mapping), por exemplo, NHibernate, Fluent NHibernate, Entity Framework entre outros;
• Utilizar ADO.NET puro;
• Ficar maluco tentando escrever ArcObjects esperto o suficiente para dar conta de seus problemas;

As alternativas, estão em ordem: da melhor para pior. O primeiro caso, de um ORM, teremos maior controle sobre nossas coisas, classes específicas para cada entidade ou para cada punhado de entidades (de acordo com sua necessidade) e teremos uma camada de domínio forte.

Mas ORMs comuns tem um problema: não utilizam as interfaces nativas do ArcObjects para acesso à dados, e nos leva, novamente as famosas gambetas. Exemplo: é ótimo acessar dados diretamente do banco de dados. É, em termos, mais rápido, mais confiável.

Mas inviabiliza completamente o uso de versionamento (pelo menos o nativo do ArcSDE), topologia, histórico, entre outras coisinhas mais, as quais pagamos à ESRI. Ou seja, estamos mutilando, para nosso próprio benefício (como desenvolvedor – facilitar nosso trampo!) o software que nosso cliente comprou.

Nenhuma das outras alternativas é muito atraente pois incentiva os desenvolvedores à prática feia do Ctrl+C/Ctrl+V – você acaba tendo de repetir querys e regras de negócio por todo o código e você arruina qualquer chance de testabilidade (a capacidade de testar e garantir que seu código funciona!)

Bem, a outra alternativa, é tentar: olhe bem, eu disse tentar, utilizar um padrão de projeto para dar conta de todos esses problemas que enfrentamos. Criar uma forma de acessar os dados dentro do geodatabase utilizando as ferramentas nativas, ou seja, ArcObjects.

É um desafio e tanto, já que é muito difícil controlar alguns aspectos desses objetos. (maldito erro COM! quem já viu um “COM object that has been separated from it’s underlying RCW cannot be used” sabe do que eu estou falando.)

Após estudar e fazer diversas tentativas de escrever algo que funcionasse, fosse de certa forma perfomático (pelo menos na mesma velocidade do acesso nativa aos objetos ou até um cadinho mais lento) e trouxesse produtividade, cheguei à um padrão projeto interessante: ActiveRecord.

É um padrão que basicamente tem um objeto vindo do banco de dados e propriedades que expõem comportamentos básicos de acesso e escrita ao objeto. Outro componente essencial é um repositório (outro padrão de projeto), que vai ser o responsável por conhecer nossas regras de acesso e como chegar ao banco de dados.

Um exemplo simples e não completamente estruturado:

public class Lote
{
	private IObject _ObjetoBanco;

	public Lote(IObject lote)
	{
		_ObjectBanco = lote;
	}

	public int IdentidadeLote
	{
		get { return Convert.ToInt32(_ObjetoBanco.get_value(1)); }
		set { _ObjetoBanco.set_Value(1); }
	}

	public string NomeProprietario
	{
		get { return _ObjetoBanco.get_Valeu(2).ToString(); }
		set { _ObjetoBanco.set_Value(2).ToString(); }
	}

	public void Salvar()
	{
		// comando ArcObjects para persistir o objeto na base
		_ObjetoBanco.Store();
	}
}

Veja que conseguimos mapear nossas colunas em único lugar e tratar este objeto por igual em qualquer lugar de nossa aplicação?

O problema de nosso primeiro exemplo, enquanto ele funciona, misturamos diversas funcionalidades e resposabilidade distintas em um único objeto. Ele sabe como ir ao banco, como mapear as colunas, e como jogá-las na tela. Caso precisássemos de ir ao banco novamente, em outra ocasião, teríamos de escrever a query novamente.

Existem outros padrões que podem auxiliar na mesma tarefa, mas a grande questão está na presença de código ArcObjects. Sem ele, fica difícil garantir que tudo funciona.

Existem duas implementações .NET para o padrão Active Record:

• Castle Active Record (que é construído em cima do NHibernate);
• nHydrate

A grande idéia aqui, é estudar o código de ambos e trazer uma implementação utilizando código ArcObjects. Não sei se é uma grande idéia, ou se não tem absolutamente valor algum (outras alternativas já são melhores).

Já tenho algo em desenvolvimento e quem tiver interesse, entre em contato que disponibilizo o link para o controle de versão do código.

E aí pessoal, o que acharam? São tópicos razoavelmente avançados, mas nada muito difícil de compreender. Fiquem à vontade para tecer comentários.

Abraços

George R. C. Silva

Related posts:

1. ArcObjects e Class Extensions #2
2. ArcObjects e Class Extensions #1
3. Cascading Class Extensions

Lembram do artigo #1 sobre as class extensions? Falei um pouco sobre como as CEs funcionam? Dê lida aqui antes de ler este aqui.

Bem, as class extensions são um pouco difíceis de se manter, pois elas geram muito código, são controladas de forma esotérica (através de IPropertySet’s) e podem controlar alguns eventos importantes, como OnChange, OnCreate e OnDelete bem como as validações de uma feição.

Portanto, qual é uma maneira um pouco mais sã de construí-las? Uma primeira tentativa que fiz, foi utilizar herança para construí-las. Uma classe base com algumas funcionalidades era herdada por classes mais “abaixo” na cadeia e ia herdando funcionalidade. Mas como dizem por aí, composição é melhor que herança para extensão de função.

Na figura acima, percebemos que toda a funcionalidade é herdada através de herança. Todas as operações em OldBaseClassExtension (a mãe de todas) são marcadas como virtual, dando a possibilidade de sobreescrevemos o método pela classe filha.

Em código temos algo assim:

    public interface IOldClassExtension : IClassExtension, IObjectClassExtension, IObjectClassValidation, IObjectClassEvents
    {
        // aqui dizemos que todas as classes derivadas de IOldClassExtension
        // devem implementar os métodos das interfaces correspondentes.
    }

    public class OldBaseClassExtension:IOldClassExtension
    {
        public virtual void Init(IClassHelper ClassHelper, ESRI.ArcGIS.esriSystem.IPropertySet ExtensionProperties)
        {
            throw new NotImplementedException();
        }

        public virtual void Shutdown()
        {
            throw new NotImplementedException();
        }

        public virtual string ValidateField(IRow Row, string FieldName)
        {
            throw new NotImplementedException();
        }

        public virtual string ValidateRow(IRow Row)
        {
            throw new NotImplementedException();
        }

        public virtual void OnChange(IObject obj)
        {
            throw new NotImplementedException();
        }

        public virtual void OnCreate(IObject obj)
        {
            throw new NotImplementedException();
        }

        public virtual void OnDelete(IObject obj)
        {
            throw new NotImplementedException();
        }
    }

    public class OldConcreteClassExtensionA : OldBaseClassExtension
    {
        public override void Init(IClassHelper ClassHelper, ESRI.ArcGIS.esriSystem.IPropertySet ExtensionProperties)
        {
            base.Init(ClassHelper, ExtensionProperties);
            // nova funcionalidade customizada
        }

        public override void Shutdown()
        {
            base.Shutdown();
            // nova funcionalidade customizada
        }

        public override string ValidateField(IRow Row, string FieldName)
        {
            base.ValidateField(Row, FieldName);
            // nova funcionalidade customizada
            return "resultado de nova validação de campo";
        }

        public override string ValidateRow(IRow Row)
        {
            base.ValidateRow(Row);
            // nova funcionalidade customizada
            return "resultado de nova validação de linha";
        }

        public override void OnChange(IObject obj)
        {
            base.OnChange(obj);
            // nova funcionalidade customizada
        }

        public override void OnCreate(IObject obj)
        {
            base.OnCreate(obj);
            // nova funcionalidade customizada
        }

        public override void OnDelete(IObject obj)
        {
            base.OnDelete(obj);
            // nova funcionalidade customizada
        }
    }

    public class OldConcreteClassExtensionB : OldBaseClassExtension
    {
        public override void Init(IClassHelper ClassHelper, ESRI.ArcGIS.esriSystem.IPropertySet ExtensionProperties)
        {
            base.Init(ClassHelper, ExtensionProperties);
            // nova funcionalidade customizada
        }

        public override void Shutdown()
        {
            base.Shutdown();
            // nova funcionalidade customizada
        }

        public override string ValidateField(IRow Row, string FieldName)
        {
            base.ValidateField(Row, FieldName);
            // nova funcionalidade customizada
            return "resultado de nova validação de campo";
        }

        public override string ValidateRow(IRow Row)
        {
            base.ValidateRow(Row);
            // nova funcionalidade customizada
            return "resultado de nova validação de linha";
        }

        public override void OnChange(IObject obj)
        {
            base.OnChange(obj);
            // nova funcionalidade customizada
        }

        public override void OnCreate(IObject obj)
        {
            base.OnCreate(obj);
            // nova funcionalidade customizada
        }

        public override void OnDelete(IObject obj)
        {
            base.OnDelete(obj);
            // nova funcionalidade customizada
        }
    }

    public class OldConcreteClassExtensionC : OldConcreteClassExtensionA
    {
        public override void Init(IClassHelper ClassHelper, ESRI.ArcGIS.esriSystem.IPropertySet ExtensionProperties)
        {
            base.Init(ClassHelper, ExtensionProperties);
            // nova funcionalidade customizada
        }

        public override void Shutdown()
        {
            base.Shutdown();
            // nova funcionalidade customizada
        }

        public override string ValidateField(IRow Row, string FieldName)
        {
            base.ValidateField(Row, FieldName);
            // nova funcionalidade customizada
            return "resultado de nova validação de campo";
        }

        public override string ValidateRow(IRow Row)
        {
            base.ValidateRow(Row);
            // nova funcionalidade customizada
            return "resultado de nova validação de linha";
        }

        public override void OnChange(IObject obj)
        {
            base.OnChange(obj);
            // nova funcionalidade customizada
        }

        public override void OnCreate(IObject obj)
        {
            base.OnCreate(obj);
            // nova funcionalidade customizada
        }

        public override void OnDelete(IObject obj)
        {
            base.OnDelete(obj);
            // nova funcionalidade customizada
        }
    }

Perceba como determinamos a funcionalidade nas classes filhas: além de herdarmos e sobreescrevermos o método, chamamos também o método base, através de base.OnChange(obj), por exemplo.

Ok, funciona, mas quando temos algumas Class Extensions e uma hierarquia com dois ou três níveis já se torna impossível de manter e debugar o código. Demora-se muito para atingir um resultado razoável.

Como faríamos se usássemos composição? Bem, vamos imaginar o seguinte: temos algumas tabelas que descrevem as class extensions de acordo com sua funcionalidade básica (nem todas as CEs precisam implementar IObjectClassValidation, caso não às usem) e uma forma de ler e instanciar estas CEs de acordo com esta tabela. O diagrama de classes seria basicamente este aqui:

Desta maneira temos um código muito mais simples e nenhuma dependência entre cada ClassExtension. Todas as CEs implementariam ICustomClassExtension, pois esta dá visibilidade para todos os eventos / validações (poderíiamos até ter implementado IObjectInspector para dar formas diferentes de edição à cada CE) que precisamos e o sistema faria o restante, consultado o banco de dados (poderia esta dentro de um próprio FileGeodatabase/ArcSDE) e descobrindo à ordem e quais CEs devem ser instanciadas.

O esquema em SQL ficaria parecido com:

CREATE TABLE ENTIDADES
(
  -- conterá uma lista de feature classes ou de tabelas do ArcGIS
  nome_entidade varchar(128) NOT NULL, -- Lote
  nome_feature_dataset varchar(128) NOT NULL DEFAULT '', -- nome do feature dataset, caso exista
  nome_feature_class varchar(128) NOT NULL, -- nome da feature class, ex: FLTE_LOTES
  CONSTRAINT entidades_pk PRIMARY KEY (nome_entidade)
)

CREATE TABLE CLASS_EXTENSIONS
(
  -- conterá uma lista das class extensions disponíveis em determinada assembly.
  nome_class_extension varchar(128) NOT NULL, -- Validar Geometria de Lote
  descricao_namespace varchar(128) NOT NULL, -- ValidateParcelGeometryExtensions
  CONSTRAINT class_extensions_pk PRIMARY KEY (nome_class_extension),
  CONSTRAINT descricao_namespace_un UNIQUE (descricao_namespace)
)

-- tabela de relacionamento entre entidades e class extensions
-- é um relacionamento M:N
CREATE TABLE ENTIDADE_POSSUI_CLASS_EXTENSION
(
  nome_entidade varchar(128) NOT NULL REFERENCES ENTIDADES on (nome_entidade),
  nome_class_extension varchar(128) NOT NULL REFERENCES CLASS_EXTENSIONS on (nome_class_extension),
  ordem_criacao integer NOT NULL DEFAULT 0,
  CONSTRAINT epc_pk PRIMARY KEY (nome_entidade,nome_class_extension,ordem_criacao)
)

Através de um pouco de código C#, podemos descobrir se a classe implementada está disponível, instanciá-la dinamicamente e adicioná-la à uma lista de ClassExtensions (propriedade extensions em ICustomClassExtension). Aqui segue um pouco de código para vocês verem a diferença. Dessa forma cada classe cuida só do que ela precisa e podemos compor dinamicamente class extensions poderosas, apenas alterando os registros presentes no banco de dados e contando que os campos manipulados por cada uma exista na feature class.

    public interface ICustomClassExtension:IClassExtension,IObjectClassExtension,IObjectClassEvents,IObjectClassValidation
    {
        List extensions { get; set; }
        void CreateExtensions();
    }

    // esta é a classe mais importante. ela provê toda a funcionalidade
    // básica de buscar o banco de dados e encontrar quem são as extensões para
    // cada feature class e como usá-las
    public class CustomClassExtension:ICustomClassExtension
    {
        public List extensions
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public void CreateExtensions()
        {
            // vá ao banco de dados e descubra quem são as class extensions aplicáveis à esta classe
            /*
             * foreach (Record r in Query)
             * {
             *      Type t = Type.GetType(r.ClassExtensionAssemblyName) // ValidateParcelGeometry
             *      extensions.Add(Activator.CreateInstance(t));
             * }
            */
        }

        public void Init(IClassHelper ClassHelper, ESRI.ArcGIS.esriSystem.IPropertySet ExtensionProperties)
        {
            foreach (IClassExtension classEx in this.extensions)
            {
                // todas as classes implementam init
                classEx.Init(ClassHelper,ExtensionProperties);
            }
        }

        public void Shutdown()
        {
            foreach (IClassExtension classEx in this.extensions)
            {
                classEx.Shutdown();
            }
        }

        public void OnChange(IObject obj)
        {
            // so vou conseguir iterar sobre as classes que implementam IObjectClassEvents
            foreach (IObjectClassEvents classEvents in this.extensions)
            {
                classEvents.OnChange(obj);
            }
        }

        public void OnCreate(IObject obj)
        {
            // so vou conseguir iterar sobre as classes que implementam IObjectClassEvents
            foreach (IObjectClassEvents classEvents in this.extensions)
            {
                classEvents.OnCreate(obj);
            }
        }

        public void OnDelete(IObject obj)
        {
            // so vou conseguir iterar sobre as classes que implementam IObjectClassEvents
            foreach (IObjectClassEvents classEvents in this.extensions)
            {
                classEvents.OnDelete(obj);
            }
        }

        public string ValidateField(IRow Row, string FieldName)
        {
            string result = String.Empty;
            // so vou conseguir iterar sobre as classes que implementam IObjectClassValidation
            foreach (IObjectClassValidation validation in this.extensions)
            {
                result += validation.ValidateField(Row, FieldName);
            }

            return result;
        }

        public string ValidateRow(IRow Row)
        {
            string result = String.Empty;
            // so vou conseguir iterar sobre as classes que implementam IObjectClassValidation
            foreach (IObjectClassValidation validation in this.extensions)
            {
                result += validation.ValidateRow(Row);
            }

            return result;
        }
    }

    public class ValidateParcelGeometryExtensions : IClassExtension, IObjectClassExtension, IObjectClassValidation
    {
        public void Init(IClassHelper ClassHelper, ESRI.ArcGIS.esriSystem.IPropertySet ExtensionProperties)
        {
            throw new NotImplementedException();
        }

        public void Shutdown()
        {
            throw new NotImplementedException();
        }

        public string ValidateField(IRow Row, string FieldName)
        {
            throw new NotImplementedException();
        }

        public string ValidateRow(IRow Row)
        {
            throw new NotImplementedException();
        }
    }

    public class OnParcelEvents : IClassExtension, IObjectClassExtension, IObjectClassEvents
    {
        public void Init(IClassHelper ClassHelper, ESRI.ArcGIS.esriSystem.IPropertySet ExtensionProperties)
        {
            throw new NotImplementedException();
        }

        public void Shutdown()
        {
            throw new NotImplementedException();
        }

        public void OnChange(IObject obj)
        {
            throw new NotImplementedException();
        }

        public void OnCreate(IObject obj)
        {
            throw new NotImplementedException();
        }

        public void OnDelete(IObject obj)
        {
            throw new NotImplementedException();
        }
    }

    public class ValidateDwgFile : IClassExtension, IObjectClassExtension, IObjectClassValidation
    {
        public void Init(IClassHelper ClassHelper, ESRI.ArcGIS.esriSystem.IPropertySet ExtensionProperties)
        {
            throw new NotImplementedException();
        }

        public void Shutdown()
        {
            throw new NotImplementedException();
        }

        public string ValidateField(IRow Row, string FieldName)
        {
            throw new NotImplementedException();
        }

        public string ValidateRow(IRow Row)
        {
            throw new NotImplementedException();
        }
    }

As vantagens de algo assim são enormes do ponto de vista de manutenção. São três simples tabelas e uma mudança simples de estrutura de código que vai dar muito mais liberdade para os desenvolvedores e usuários. No momento em que construirmos uma nova extensão, se todos os usuários tiverem à mesma instalada no PC, é só associarmos a mesma à uma entidade que imediatamente deveria funcionar perfeitamente. Poderíamos até deixar à cargo do usuário ligar ou desligar as class extensions de seu interesse.

Entendo que este post é um ArcObjects um pouco mais avançado, mas é muito divertido ver como simples mudanças de arquitetura facilitam a vida dos desenvolvedores e transformar a forma como o usuário se relaciona com o software.

O que acharam?

Um abraço pessoal,

George R. C. Silva

Related posts:

1. Cascading Class Extensions
2. ArcObjects e Class Extensions #1
3. Padrão de Projeto ActiveRecord e ArcObjects

Class Extensions é um assunto relativamente antigo. Quem já desenvolveu para ArcObjects às conhecem razoavelmente bem e são implementadas em larga escala como forma de customização avançada dos famosos geodatabases (qualquer um deles, seja Personal, File ou ArcSDE).

Bem, as class extensions são implementadas através de algumas interfaces especiais e devem ser registradas em uma categoria apropriada (o assunto das categorias de objetos ESRI merece um post sozinho!), GeoObjectClassExtensions para funcionarem e além disso devem ser aplicadas à uma Feature Class ou Table para rodarem apropriadamente. E outra coisa: elas só funcionam com quem possui o código cliente (da Class Extension) instalado na máquina. Para quem não possui o cliente elas se comportam de maneira comum.

Com Class Extensions é possível customizar o inspetor de objetos (aquele carinha utilizado para editar os objetos), customizar a renderização de objetos (isso é poderoso!) e customizar a validação realizada pelo ArcGIS antes da feature receber uma chamada no método Store() (ou seja, antes de ir para o banco);

Existem diversas coisas legais que podemos fazer com estas class extensions e não existe muita dificuldade de implementação (claro, quanto mais requisitos ou quanto mais complexos, mais complicado é de implementar e manter uma CE.).

As CEs podem existes para os seguintes tipos:

• Features
• Rows
• Quaisquer tipos derivados de IRow

O que isto quer dizer? Bem, tanto tabelas, quanto feature classes e qualquer objeto derivado disto podem ter CEs.

Os requerimentos/limitações para Class Extensions são:

• Feature classes e tabelas só podem ter uma class extension;
• A CE precisa ser registrada na categoria apropriada (GeoObjectClassExtensions)
• A funcionalidade não está presente no repositório de dados e sim no cliente. Sempre será necessário realizar o deploy de todo o código das CEs em todos os clientes;

Não são requerimentos/limitações muito pesadas, portanto é uma alternativa viável para customizações mais complexas do procedimento de edição/criação/deleção de objetos.

Obrigatoriamente, o desenvolvedor precisa implementar as seguintes interfaces: IObjectClassExtension (e IFeatureClassExtension, caso seja uma extensão para feature classes). Neste ponto, nossa CE não tem nenhuma funcionalidade. Ela apenas existe.

Para adicionar funcionalidade, podemos implementar outras interfaces, listadas à seguir:

• IObjectClassEvents
• IObjectClassValidation
• IObjectClassInfo
• IRelatedObjectClassEvents
• IConfirmSendRelatedObjectEvents
• IFeatureClassEdit
• IFeatureClassDraw
• IFeatureClassCreation
• IObjectInspector

Estas interfaces são opcionais, cada uma oferencendo um pouquinho de funcionalidade customizada. Hoje falaremos sobre IObjectClassEvents, que é uma das interfaces mais comum de se implementar. Ao longo de uma pequena série tentarei demonstrar a funcionalidade de algumas destas interfaces.

IObjectClassEvents

Esta interface é responsável por nos fornecer métodos para lidar com os eventos de criação, atualização e deleção de um registro. Pense em uma trigger de um banco de dados. Sempre que o evento disparar, determinado método será disparado em sequência.

Os métodos que devem ser implementados para total aderência ao contrato (a interface ) são:

• OnCreate(IObject obj);
• OnChange(IObject obj);
• OnDelete(IObject obj);

Um exemplo de implementação de uma CE com a interface IObjectClassEvents. Note que esta implementação não é completa, ou seja, faltam métodos para o registro da CE, inicialização correta, etc;

Imagine que temos uma tabela log de operação. Nela salvamos os registros relativos às operações realizadas por todos operadores durante o dia. Sua estrutura é a seguinte (em SQL, mas devemos considerar que a tabela está presente em um ambiente ArcGIS - Geodatabases de qualquer tipo);

CREATE TABLE LOG_OPERACAO(
OBJECTID serial NOT NULL,
NOME_TABELA VARCHAR(100) NOT NULL,
NOME_USUARIO VARCHAR(100) NOT NULL,
TIPO_OPERACAO VARCHAR(20) NOT NULL,
OID_ORIGINAL integer NOT NULL,
DATA_HORA_OPERACAO timestamp NOT NULL default now()
CONSTRAINT LOG_OPERACAO_PK PRIMARY KEY (OBJECTID)
);

    public class LogUsuario:IObjectClassExtension,IObjectClassEvents
    {
        public void OnCreate(IObject obj)
        {
            // vamos adicionar um registro à uma tabela de log de operações
            // precisamos de nosso workspace para abrir a tabela
            IFeatureWorkspace workspace = ((IDataset)obj.Class).Workspace;
            ITable logTable = workspace.OpenTable("LOG_OPERACAO");

            // só vamos tentar adicionar se a tabela existir no geodatabase!
            if (logTable != null)
            {
                // ok, a tabela existe. caso não existisse, ela seria nula
                // portanto, vamos criar um novo registro
                IRow novoRegistroLog = logTable.CreateRow();

                novoRegistroLog.set_Value(1,((IDataset)obj.Class).Name); // nome da tabela que estamos modificando
                novoRegistroLog.set_Value(1,Environment.UserName); // nome do usuario
                novoRegistroLog.set_Value(2,"INSERCAO"); // tipo da operacao
                novoRegistroLog.set_Value(3,obj.OID); // id no geodatabase
                novoRegistroLog.set_Value(4,DateTime.Now); // data e hora
                novoRegistroLog.Store();
           }
     }

        public void OnChange(IObject obj)
        {
            // vamos adicionar um registro à uma tabela de log de operações
            // precisamos de nosso workspace para abrir a tabela
            IFeatureWorkspace workspace = ((IDataset)obj.Class).Workspace;
            ITable logTable = workspace.OpenTable("LOG_OPERACAO");

            // só vamos tentar adicionar se a tabela existir no geodatabase!
            if (logTable != null)
            {
                // ok, a tabela existe. caso não existisse, ela seria nula
                // portanto, vamos criar um novo registro
                IRow novoRegistroLog = logTable.CreateRow();

                novoRegistroLog.set_Value(1,((IDataset)obj.Class).Name); // nome da tabela que estamos modificando
                novoRegistroLog.set_Value(1,Environment.UserName); // nome do usuario
                novoRegistroLog.set_Value(2,"ATUALIZACAO"); // tipo da operacao
                novoRegistroLog.set_Value(3,obj.OID); // id no geodatabase
                novoRegistroLog.set_Value(4,DateTime.Now); // data e hora
                novoRegistroLog.Store();
           }
     }

        public void OnDelete(IObject obj)
        {
            // vamos adicionar um registro à uma tabela de log de operações
            // precisamos de nosso workspace para abrir a tabela
            IFeatureWorkspace workspace = ((IDataset)obj.Class).Workspace;
            ITable logTable = workspace.OpenTable("LOG_OPERACAO");

            // só vamos tentar adicionar se a tabela existir no geodatabase!
            if (logTable != null)
            {
                // ok, a tabela existe. caso não existisse, ela seria nula
                // portanto, vamos criar um novo registro
                IRow novoRegistroLog = logTable.CreateRow();

                novoRegistroLog.set_Value(1,((IDataset)obj.Class).Name); // nome da tabela que estamos modificando
                novoRegistroLog.set_Value(1,Environment.UserName); // nome do usuario
                novoRegistroLog.set_Value(2,"INSERCAO"); // tipo da operacao
                novoRegistroLog.set_Value(3,obj.OID); // id no geodatabase
                novoRegistroLog.set_Value(4,DateTime.Now); // data e hora
                novoRegistroLog.Store();
           }
     }
}

Bem, este é um exemplo de implementação da interface IObjectClassEvents. Poderiamos ter deixado o código muito mais limpo (escrevendo uma função à parte para a criação de um registro na tabela de log, por exemplo) e implementado outras funcionalidades. O que importa é que você já sabe como implementar algumas funcionalidades extras dentro do ArcGIS. Lembrando que para esta CE funcionar precisamos aplicar a mesma à uma feature class. Para aplicar uma class extension programaticamente, preciso utilizar algo similar à isto:

public void ChangeClassExtension(IObjectClass objectClass, String extensionUID,IPropertySet extensionProperties)
{
    ISchemaLock schemaLock = (ISchemaLock)objectClass;

    try
    {
        // Attempt to get an exclusive schema lock.
        schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);

        // Cast the object class to the IClassSchemaEdit2 interface.
        IClassSchemaEdit2 classSchemaEdit = (IClassSchemaEdit2)objectClass;

        if (!extensionUID.Equals(""))
        {
            // Create a unique identifier (UID) object and change the extension.
            UID extUID = new UIDClass();
            extUID.Value = extensionUID;
            classSchemaEdit.AlterClassExtensionCLSID(extUID, extensionProperties);
        }
        else
        {
            // Clear the class extension.
            classSchemaEdit.AlterClassExtensionCLSID(null, null);
        }
    }
    catch (COMException comExc)
    {
        throw new Exception("Could not change class extension.", comExc);
    }
    finally
    {
        schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
    }
}

Este snippet de código tirado da documentação da EDN (ESRI Developer Network), instalado junto com o SDK faz as seguintes operações:

1. Tenta assumir um lock exclusivo sobre a ObjectClass (veja a interface IObjectClass);
2. Converte a object class para um class schema edit (veja IClassSchemaEdit2), para poder acessar os membros (métodos e propriedades) de edição;
3. Acha a extensão através do código GUID (é o carinho que se vê como um atributo de classe, localizado acima da declaração comum de classe, no seu projeto do Visual Studio;
4. Altera a class extension;
5. Libera o lock exclusivo (feito na chamada finally para termos garantia que o lock não ficará por lá, atoa);

O que acharam pessoal? Não é exatamente um bixo de sete cabeças, mas precisamos aprofundar nos ArcObjects para ter sucesso na implementação de class extensions úteis. O exemplo fornecido é bobo, pode ter utilidade, mas existem milhares de possibilidades com esses diabinhos. Vários produtos de nível corporativo (soluções de energia, da Miner&Miner por exemplo), apostam pesado na customização de feature classes como saída para problemas complexos.

Tentem brincar um pouquinho com as class extensions. É bem divertido e rende um trabalho interessante.

Vou ficar por aqui!

Um abraço,

George R. C. Silva

Related posts:

1. ArcObjects e Class Extensions #2
2. Padrão de Projeto ActiveRecord e ArcObjects
3. Cascading Class Extensions

Não podemos criar estas geometrias de alto nível, sem criar antes as geometrias de baixo nível que as compõe. É a maneira na qual o ArcGIS trabalha, e é a mais sã, do ponto de vista de desenvolvimento.

Primeiro vamos construir um polígono. Podemos construir os anéis separadamente, de pontos ou de segmentos e logo depois, adicionar à uma coleção de geometrias, na qual o próprio ArcGIS irá entender como um polígono.

public static IPolygon ConstruirPolígono()
    {
        object _missing = Type.Missing;

        IGeometryCollection poligonoFinal = new PolygonClass();

        // vamos criar primeiro nosso anel exterior
        // perceba com estamos utilizando uma interface IPointCollection

        IPointCollection anelExterior = new RingClass();

        // lembram da função BuildPoint do post anterior?

        anelExterior.AddPoint(BuildPoint(0,0,0),ref _missing, ref _missing);
        anelExterior.AddPoint(BuildPoint(0,1,0),ref _missing, ref _missing);
        anelExterior.AddPoint(BuildPoint(1,1,0),ref _missing, ref _missing);
        anelExterior.AddPoint(BuildPoint(1,0,0),ref _missing, ref _missing);

        // o último ponto deve ser sempre igual ao primeiro - somente assim
        // o polígono está fechado
        // podemos utilizar também uma outra técnica para usar o primeiro ponto
        // sem duplicar o ponto inicial - muito útil se você não sabe de antemão qual é o primeiro ponto.
        // anelExterior.AddPoint(anelExterior.get_Point(0),ref _missing, ref _missing);

        anelExterior.AddPoint(BuildPoint(0,0,0));

        poligono.AddGeometry(anelExterior as IGeometry, ref _missing, ref _missing);

        // definir a referência espacial - sem a referência espacial o ArcGis não realiza operações espaciais direitinho!

        return poligono as IPolygon;
}

Polígono construído com o código anterior

public static IPolygon ConstruirPolígono()
    {
        object _missing = Type.Missing;

        IGeometryCollection poligonoFinal = new PolygonClass();

        // vamos criar primeiro nosso anel exterior
        // perceba com estamos utilizando uma interface IPointCollection

        IPointCollection anelExterior = new RingClass();

        // lembram da função BuildPoint do post anterior?

        anelExterior.AddPoint(BuildPoint(0,0,0),ref _missing, ref _missing);
        anelExterior.AddPoint(BuildPoint(0,10,0),ref _missing, ref _missing);
        anelExterior.AddPoint(BuildPoint(10,10,0),ref _missing, ref _missing);
        anelExterior.AddPoint(BuildPoint(10,0,0),ref _missing, ref _missing);

        // o último ponto deve ser sempre igual ao primeiro - somente assim
        // o polígono está fechado
        // podemos utilizar também uma outra técnica para usar o primeiro ponto
        // sem duplicar o ponto inicial - muito útil se você não sabe de antemão qual é o primeiro ponto.
        anelExterior.AddPoint(anelExterior.get_Point(0),ref _missing, ref _missing);

        IPointCollection anelInterior = new RingClass();
        anelInterior.AddPoint(BuildPoint(1,1,0), ref _missing, ref _missing);
        anelInterior.AddPoint(BuildPoint(1,2,0), ref _missing, ref _missing);
        anelInterior.AddPoint(BuildPoint(2,2,0), ref _missing, ref _missing);
        anelInterior.AddPoint(BuildPoint(2,1,0), ref _missing, ref _missing);
        anelInterior.AddPoint(anelInterior.get_Point(0),ref _missing, ref _missing);

        // nao é permitido sobrepor anéis, à menos que eles tenham orientações contrárias
        // nosso anel exterior tem orientação horária - todos os anéis exteriores devem ter orientação horária!
        // anéis interiores, que descrevem buracos em nossos polígonos devem ter orientação anti-horária!
        ICurve curva = anelInterior as ICurve;
        curva.ReverseOrientation();

        poligono.AddGeometry(anelExterior as IGeometry, ref _missing, ref _missing);
        poligono.AddGeometry(anelInterior as IGeometry, ref _missing, ref _missing);

        // definir a referência espacial - sem a referência espacial o ArcGis não realiza operações espaciais direitinho!

        return poligono as IPolygon;
}

Polígono simples criado pelo código acima (fora de escala)

Bem, é fácil trabalhar com geometrias da ESRI. Claro, quanto mais complexa a geometria, mais complexo deverá ser o código para cuidar da mesma. Mas não é nenhum bixo de 7 cabeças. Um outro detalhe interessante é que revertemos a orientação da geometria interna usando uma outra interface, e adicionamos nosso anel original. Por que funciona? A biblioteca ArcObjects fica responsável por notificar a geometria original de que certa operação ocorreu e a realiza de acordo.

Em geral, os passos para se trabalhar com geometrias complexas é construir anéis ou segmentos, criados através da interface IPointCollection, pois assim podemos ir adicionando os pontos que temos interesse e depois ajeitar a orientação de cada anel para nos dar o resultado desejado.

Certo, mas e um polígono que contenha curvas? O formato shapefile não suporta(va) o desenho delas e estão disponíveis à partir dos geodatabases (as curvas são convertidas em diversos segmentos, aproximando o resultado. Mas podemos criar um polígon com curvas via código? Sim, claro! O segredo, neste caso, é separar cada segmento em um anel, mesmo que ele, no final, seja parte de uma coisa só.

Vamos criar dois anéis, um para nosso segmento curvo e o outro para nossos segmentos retos. Juntaremos os dois em apenas um anel e depois adicionaremos este anel ao polígono.

Para construir segmentos curvos, existem diversas interfaces do tipo IConstruct* (IConstructCircularArc, IConstructBezierCurve, etc.), cada uma com suas particularidades.

object _missing = Type.Missing;

        IGeometryCollection polygon = new PolygonClass();

        // building circular arc

        IPoint p1 = PointPolygonBuilder.BuildPoint(1, 2);
        IPoint p2 = PointPolygonBuilder.BuildPoint(1, 1);
        IPoint p3 = PointPolygonBuilder.BuildPoint(1, 0);
        IPoint p4 = PointPolygonBuilder.BuildPoint(0, 0);
        IPoint p5 = PointPolygonBuilder.BuildPoint(0, 1);

        IConstructCircularArc constructCircularArc = new CircularArcClass();
        constructCircularArc.ConstructThreePoints(p5, p2, p1, true);
        ICircularArc circularArc = constructCircularArc as ICircularArc;
        // end circular Arc

        ISegmentCollection finalRing = new RingClass();
        ISegmentCollection ring1 = new RingClass();
        IPointCollection ring2 = new RingClass();

        ring1.AddSegment(circularArc as ISegment, ref _missing, ref _missing);
        ring2.AddPoint(p1, ref _missing, ref _missing);
        ring2.AddPoint(p3, ref _missing, ref _missing);
        ring2.AddPoint(p4, ref _missing, ref _missing);
        ring2.AddPoint(p5, ref _missing, ref _missing);

        finalRing.AddSegmentCollection(ring1);
        finalRing.AddSegmentCollection(ring2 as ISegmentCollection);
        polygon.AddGeometry(finalRing as IGeometry, ref _missing, ref _missing);

Polígono resultante do código acima

Note que deu um trabalhinho à mais para montar este segmento curvo. É bom deixar claro também, que o ponto (1,1) representado na figura, não entra no anel feito de segmentos retos, ele é apenas utilizado para construir o segmento curvo.

Outra coisa legal é ver que para acessar alguns métodos, você tem que instanciar certas interfaces. Notem que o finalRing e ring1 possuem propriedades semelhantes, pois têm a mesma interface. Já ring2 possui outros membros, pois é de interface diferente. Classes iguais, interfaces diferentes = propriedades diferentes.

E aí, o que acharam?

Abraços pessoal!

George R. C. Silva

Related posts:

1. Brincando com ArcObjects
2. Funções PostGIS #3
3. ArcObjects #1 – introdução

ArcObjects é algo relativamente difícil. É complicado pois temos muitas formas de se fazer o que queremos, a documentação - apesar de razoável, não é excelente (existem detalhes importantes que podem estar escondidos em outras páginas) e não existe uma comunidade forte que trate destas questões.

Gostaria de mostrar um pouco de ArcObjects aos iniciantes, em especial um namespace complicadinho: ESRI.ArcGIS.Geometry. Não tenho domínio do namespace suficiente para dizer que sou um expert, mas consigo me virar.

O namespace Geometry é o responsável por cuidar de todas as operações com as geometrias, sejam elas de quaisquer tipos. Primeiramente gostaria de apresentaar à vocês aos tipos de geometria de alto-nível. Isto é importante pois algumas funções ou interfaces, só estão disponíveis nas geometrias de alto nível, outras somente nas de baixo nível.

Todas as geometrias de alto nível tem à sua disposição um set teórico de operações possíveis, tais como interseção, união, diferença, diferença simétrica, entre outros. Outras interfaces/classes do namespace ESRI.ArcGIS.Geometry são responsáveis por estas operações.

Geometrias de Alto Nível

As geometrias de alto nível são:

• Points;
• Multipoints;
• Polylines;
• Polygons;
• MultiPatches;

Ponto é o tipo de geometria mais simples que podemos encontrar no modelo do ArcGIS. É basicamente composta de uma coordenada X e uma coordenada Y. Opcionalmente os pontos podem ser IdAware, ZAware e MAware, ou seja: podem ter um Id, Z e M. Todas os tipos de geometrias podem ter estes atributos em seus vértices, que em suma, são pontos.

Multipontos é um tipo de geometria representado por uma coleção de pontos. Da mesma maneira que um ponto, cada ponto desta única geometria tem seus atributos.

Polilinhas são composta pela união de diversos paths (uma geometria de nível mais baixo) que são compostos por sua vez de diversos segments, que podem ser dos tipos: linha, arco circular, curva bezier ou arco elíptico.

Polígonos são geometrias compostas por rings, que são compostos por segments, dos tipos citados acima. A ordem de cada ring e o sentido de construção (horário/ante-horário) determinar o comportamento de cada ring. Exemplo: todos os rings externos são ordenados em sentido horário, indicando que o interior dele é o polígono. Caso um ring seja ordenado em anti-horário você está dizendo ao ArcGIS que ele é hole - com área negativa.

No caso dos polígonos, isso pode ocorrer indefinidamente, sendo determinado pela ordem em que cada ring aparece na coleção.

Ilustração do funcionamento de rings e polígonos - Fonte: ESRI

Multipatches são geometrias compostas e são em três dimensões. São geometrias que podem ter múltiplas superfícies, com textura. É a forma como o ArcGIS representa objetos em três dimensões. São compostas de Triangles, TriangleStrips e TriangleFans.

Todas as geometrias de nível mais baixo são construídas necessáriamente por pontos. É o bloco de construção do ArcGIS.

Geometrias de Baixo Nível

• Paths
• Rings
• Segments
• TriangleStrips
• TriangleFans
• Triangles

Diagrama mostrando a estrutura de Polyline - Fonte: ESRI

Diagrama mostrando à estrutura de Polygon - Fonte: ESRI

Pela estrutura que temos aí dá pra entender melhor não?

Vamos começar brincando com os pontinhos, já que são as estruturas básicas de trabalho.

Classes e Interfaces

Para simplificar para os iniciantes, classe é um projeto de um objeto. Quando criamos um novo, aquele projeto é "materializado" na memória do computador.

Interface é um contrato. Quando dizemos que uma classe implementa uma interface, queremos dizer que aquela classe assinou um contrato de funcionalidade com aquela interface - ou seja, tudo que realiza operações na interface ou em algum membro da interface, está também disponível na classe, sendo possível utilizar aquela classe em alguma função que requer a interface.

PointClass

Esta classe implementa diversas interfaces (ou contratos) do namespace Geometry. As interfaces definem as funcionalidades que a PointClass terá. Caso você tenha o Help de desenvolvimento do ArcGIS instalado, abra o mesmo e procure esta URL ms-help://ESRI.EDNv9.3/esriGeometry/html/Point.htm .

Caso não tenha o help instalado

Como criamos um novo ponto? É bem simples, vejam só.

    IPoint ponto = new PointClass();
    ponto.PutCoords(10,10);

Vamos criar uma novo projeto C# do tipo ArcGIS>Console Application. Adicione as referências:

• ESRI.ArcGIS.Geometry;
• ESRI.ArcGIS.Framework;
• ESRI.ArcGIS.esriSystem;

Você verá que o Visual Studio já criou algumas linhas código para nós. Este é o código para buscar a licença na máquina. Em qualquer tipo de aplicação que você for construir, você deve ter um código similar para buscar uma licença, senão ele é automaticamente desligado.

namespace DesktopConsoleApplication1
{
    class Program
    {
        private static LicenseInitializer m_AOLicenseInitializer = new DesktopConsoleApplication1.LicenseInitializer();

        [STAThread()]
        static void Main(string[] args)
        {
            //ESRI License Initializer generated code.
            m_AOLicenseInitializer.InitializeApplication(new esriLicenseProductCode[] { esriLicenseProductCode.esriLicenseProductCodeArcView },
            new esriLicenseExtensionCode[] { });
            //ESRI License Initializer generated code.
            //Do not make any call to ArcObjects after ShutDownApplication()
            m_AOLicenseInitializer.ShutdownApplication();
        }
    }
}

Este é como meu código se parece. O método Main é o que executa o programa de verdade. Para demonstrar o funcionamento da interface IPoint e da PointClass, vamos escrever algo bem simples, para ilustrar.

Acima do namespace, adicione as seguintes linhas:

using ESRI.ArcGIS.Geometry;
using ESRI.ArcGIS.Framework;

Elas são necessárias para utilizarmos os objetos contidos nestes namespaces sem qualificá-los totalmente, ex: ESRI.ArcGIS.Geometry.IPoint. Após a adição destas linhas, podemos utilizar somente IPoint, diretamente, pois estes objetos estão à nossa disposição.

Crie um novo método dentro desta classe (isto não é o ideal em código de produção - estude orientação à objetos. este é apenas um exemplo) chamado BuildPoint. Este método deve ser estático (não queremos ter de criar uma outra classe Program para acessá-lo), ou seja, pode ser acessado no "projeto" da classe (ao invés de funcionar no objeto). Neste método, queremos construir um ponto, designar suas coordenadas x, y e z e queremos que esta função nos devolva este ponto.

Ficaria assim:

        static IPoint BuildPoint(double x, double y, double z)
        {
            IPoint ponto = new PointClass();
            ponto.PutCoords(x, y);
            ponto.Z = z;

            return ponto;
        }

Sugiro que você não façam somente um Ctrl-C + Ctrl-V dos códigos. Teste isto no Visual Studio. O Intelllisense irá lhe mostrar algumas outras coisinhas interessantes. Não esqueça de consultar a documentação para saber mais sobre cada um dos membros e métodos.

Bem, o que este método faz? Ele simplesmente instancia um novo ponto, atualiza as coordenadas conformes passadas nos argumentos da função e nos devolve o ponto. Para que fazer uma função assim? Bem, são somente 4 linhas de código, mas imagine se você precisa criar 80000 pontos? Certo, então temos nossa primeira função pronta.

O que faremos com ela? Vamos modificar nosso método Main, para ler diversas coordenadas e criar um monte de pontos para nós. Depois iremos pedir para nosso método Main nos mostrar os pontos criados. Além de modificar o Main, vamos construir um segundo método para nos ajudar a criar os pontos.

Vamos lá:

        [STAThread()]
        static void Main(string[] args)
        {
            //ESRI License Initializer generated code.
            m_AOLicenseInitializer.InitializeApplication(new esriLicenseProductCode[] { esriLicenseProductCode.esriLicenseProductCodeArcView },
            new esriLicenseExtensionCode[] { });
            //ESRI License Initializer generated code.
            //Do not make any call to ArcObjects after ShutDownApplication()
            m_AOLicenseInitializer.ShutdownApplication();

            // após a inicialização da licença, vamos brincar
            string finaliza = "s";
            string leitura;

            // aqui guardaremos nossos pontos
            List listaDePontos = new List();

            // enquanto finaliza for diferente de n, repita:
            while (finaliza.Substring(0,1).ToLower() != "n")
            {
                // vamos dizer ao usuário o que precisamos.
                Console.WriteLine("Digite as coordenadas de seu ponto. Utilize vírgulas para separá-las");
                Console.WriteLine("X,Y,Z");

                // leitura guardará o resultado que nosso usuário digitar!
                leitura = Console.ReadLine();

                // temos uma string. precisamos de um método para quebrá-la
                // e nos devolver um ponto - que será inserido na listaDePontos
                listaDePontos.Add(TraduzirStringPonto(leitura));

                // será que o usuário quer digitar mais pontos?
                Console.WriteLine("Você deseja criar mais pontos? n para não");
                // vamos alterar o valor de finaliza, que será testa mais à frente.
                // note que esta rotina não cobre TODAS AS POSSIBILIDADES
                finaliza = Console.ReadLine();
            }

            // agora que o usuário terminou de criar seus pontos,
            // vamos mostrá-los à ele.
            Console.WriteLine();
            Console.WriteLine("Lista de Pontos:\n");

            // para cada variável do tipo IPoint em listaDePontos, faça
            foreach (IPoint p in listaDePontos)
            {
                // \t é caractere de tabulação.
                Console.Write("ID " + p.ID.ToString() + "\t");
                Console.Write("X " + p.X.ToString() + "\t");
                Console.Write("Y " + p.Y.ToString() + "\t");
                Console.Write("Z " + p.Z.ToString() + "\t");
                Console.WriteLine();
            }
            // vamos esperar o usuário ler os dados e assim que ele teclar denovo
            // finalizamos o programa
            Console.WriteLine();
            Console.WriteLine("Aperte qualquer botão do teclado para finalizar...");
            Console.ReadLine();
        }

No meio da função está a lógica do programa. Queremos ler dados, até o usuário dizer não. Note que este programa é bastante simples, não realiza verificação de erros nem os trata. Não deve ser feito assim na vida real!

Mostramos para o usuário algumas propriedades da classse IPoint, algumas setadas por nós, outras não. Viram que todos os IDs são iguais à zero?

Agora vou lhes mostrar a função TraduzirStringPonto. Ela envolve mais programação comum, do que ArcObjects. Vou mostrá-la só para não ficarem no escuro

        static IPoint TraduzirStringPonto(string s)
        {
            // recebemos nesta função uma string e queremos transformá-la em números
            // vamos usar o método Split, que tem como argumentos um array de caracteres
            // delimitados como as strings, com a exceção de que usamos aspas simples!
            string[] arrayDeStrings = s.Split(new Char[]{','},3);

            // vamos criar uma array com três posições para receber nossos números!
            double[] arrayDeDoubles = new double[3];

            // para i = 0 até i = 2
            for(int i = 0; i <= 2; i++)
            {
                // assinale o valor da posição i em arrayDeDoubles
                // para ser igual ao valor da posição i em arrayDeStrings,
                // convertendo-os para um objeto do tipo Double
                arrayDeDoubles[i] = Double.Parse(arrayDeStrings[i]);
            }

            // vamos criar nosso ponto. lembra de BuildPoint?
            IPoint ponto = BuildPoint(arrayDeDoubles[0],arrayDeDoubles[1],arrayDeDoubles[2]);

            // nos devolva nosso ponto para que possamos inseri-lo na lista
            return ponto;
        }

Novamente um aviso: esta função também não tem identificação de erros ou tratamento dos mesmos. Recomendo ao interessado em desenvolver seu método de validação da entrada de dados, pois se inserirmos em nosso programa os valores:

10,eitcha,100

ele irá simplesmente travar - no momento da conversão de string para double.

Esta foi uma gentil introdução à manipulação de geometrias em ArcObjects. Os próximos passos são um pouco mais cabeludos, mas nada que seja impossível.

O que acharam?

Related posts:

1. Brincando com ArcObjects #2
2. ArcObjects e Class Extensions #2
3. Padrão de Projeto ActiveRecord e ArcObjects

Sejam bem-vindos à mais nova série de postagens do Blog Geo.NET: Congonha's Post.

Bem, ela tem esse nome porque estou postando do aeroporto de Congonhas e hoje vamos falar, rapidinho, sobre máquinas virtuais e o desenvolvimento para ArcObjects. (estava postando do aeroporto de Congonhas, mas meu voô ia sair sem mim, então tive de deixar para hoje )

Desenvolver para ArcObjects é complicado. Temos de referenciar diversas bibliotecas, instalar diversos softwares para nos auxiliar e temos, no final de tudo, de fazer o deploy de nossos componentes customizados.

Estes dias anteriores, durante um trabalho em um dos clientes, tive de realizar o deploy de um componente customizado, que cuida de simbologia de algumas camadas (em torno de 200).

Estava me dando um trabalhão. Montava um executável, enviava o executável para um máquina de testes, instalava o software, testava. Deu erro? Desinstala o software e começa tudo denovo.

Aí me sugeriram: pegue uma máquina virtual e monte um ambiente similar ao em que realizaremos o deploy final.

Existem diversos softwares para montarmos máquinas virtuais, mas existe um simples, gratuito e da Microsoft que resolve horrores. Virtual PC. Só fazer o download e instalar o sistema (Windows) que você quiser. Do 95 ao 7 . Você pede para criar a máquina virtual, aloca uma certa quantidade de RAM e HD para a mesma, e voilá, você tem um PC dentro do seu PC.

Como isto facilitou minha vida? Ganhei no mínimo, uns quatros dias de trabalho. Instalei a VM (Virtual Machine), abri uma instância do Windows XP, coloquei um ArcGIS 9.3 e fui realizando os ajustes até finalizar.

Agora, o que é legal é que você pode montar diversas instâncias e testar a backwards compatibility (compatibilidade retroativa - ou algo do tipo) com outras versões, de ArcGIS, de ArcServer, enfim, de diversos ambientes diferentes.

Estou com duas máquinas virtuais, as duas com WinXP SP3, uma com ArcGIS 9.3 e a outra com ArcGIS 9.2.

Fica aí a dica.

George R. C. Silva

Related posts:

1. ArcObjects #1 – introdução
2. ArcObjects e Class Extensions #2
3. Brincando com ArcObjects

Conforme prometi, vamos começar a brincar de ArcObjects.

Se vocês instalaram o Visual Studio 2005 (pode ser o Express, disponível gratuitamente) e depois instalaram o software development kit vocês não teram problema para acompanhar este simples guia.

Notas importantes

• Não irei focar no código. Não irei explicar detalhadamente o que cada função faz. Isto é trabalho de vocês.
• Irei ajudar na parte mais difícil: como começar. Existem algumas coisinhas que são chatíssimas quando programamos para ArcGIS, mas ainda bem que o próprio Visual Studio resolve algumas delas para nós.

Início

Primeiramente, abra o Visual Studio e peça um New Project. Selecione um Empty Project e dê um nome para seu projeto.

Criando um novo projeto no Visual Studio 2005

Depois de isso feito, termos algo mais ou menos assim:

Projeto vazio

O Visual Studio é extremamente personalizável, portanto não precisa se concentar em deixar sua tela exatamente igual a minha. Quero que você veja o Solution Explorer que fica à direita.

Vamos para o rock. O que iremos fazer?

Vamos criar uma simples barrinha de ferramentas que nos avisa quantas camadas temos em um determinado MXD. Simples né? Besta né? Mas isso vai ser o fundamento, coisas mais complexas virão.

Então vamos lá. Vá na raiz do projeto (escrito HelloWorldArcGIS) e clique com o botão direito. Clique em Add ArcGIS Reference.

O que isto exatamente faz? Bem, o ArcGIS como diversos softwares, são muito grandes, e não podemos/devemos referenciar todo o código junto. Para que adicionar referências que não iremos utilizar?

Certo, quando você clicar no botãozinho, irá aparecer uma janelinha. Vá na opção Desktop ArcMap e adicione as seguintes assemblies:

• ESRI.ArcGIS.ArcMapUI;
• ESRI.ArcGIS.ArcMap;
• ESRI.ArcGIS.Display;
• ESRI.ArcGIS.Framework;
• ESRI.ArcGIS.Geodatabase;
• ESRI.ArcGIS.System;
• ESRI.ArcGIS.Carto;

Clique em Finish.

Você verá que a pasta References foi atualizada. Vamos adicionar algumas assemblies do Windows e do .NET.

Siga o mesmo passo acima, mas ao invés de escolher Add ArcGIS Reference, escolha Add Reference. Uma caixinha irá se abrir, portanto em .NET, seleciona as seguintes assemblies:

• System
• System.Drawing
• System.Windows.Forms

Clique ok. Estamos good to go.

Nossas referências estão no lugar. Isto significa que poderemos utilizar código pronto contido nestas assemblies. Isto é importante e interessante que se aprenda cedo, senão algo pode deixar de funcionar simplesmente porque você nao colocou aquela referência...

Vamos agora criar uma barra de ferramentas para colocar nossas coisinhas nela.

Clique com o botão direito na raiz do projeto e clique em Add > Add New Item.

Adicionando uma barra de ferramentas

Selecione Base Toolbar e dê um nome à esta toolbar. Algo como HelloWorldToolbar, e clique em Add. Um tela irá aparecer perguntando qual tipo de barra de ferramentas você quer. Selecione ArcMap e boa.

Olhe suas referências. Elas foram atualizadas e adicionados alguns assemblies extras. Não se preocupe com eles. O Visual Studio é até inteligente para colocar algumas que você pode ter esquecido, mas só pelos canais oficiais (como este de adicionar uma toolbar). Se você criar uma classe e tentar herdar de BaseToolbar você provavelmente ganhará um erro.

Ele abriu um arquivo de código com a extensão .cs que contém diversas coisas, uns números muito doidos e por aí vai. Vamos explicar:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using ESRI.ArcGIS.ADF.CATIDs;
using ESRI.ArcGIS.ADF.BaseClasses;

namespace HelloWorldArcGIS
{
    ///
    /// Summary description for HelloWorldToolbar.
    ///
    [Guid("cc7ed839-de6c-46a7-9817-f4a3756cc57c")]
    [ClassInterface(ClassInterfaceType.None)]
    [ProgId("HelloWorldArcGIS.HelloWorldToolbar")]
    public sealed class HelloWorldToolbar : BaseToolbar
    {
        #region COM Registration Function(s)
        [ComRegisterFunction()]
        [ComVisible(false)]
        static void RegisterFunction(Type registerType)
        {
            // Required for ArcGIS Component Category Registrar support
            ArcGISCategoryRegistration(registerType);

            //
            // TODO: Add any COM registration code here
            //
        }

        [ComUnregisterFunction()]
        [ComVisible(false)]
        static void UnregisterFunction(Type registerType)
        {
            // Required for ArcGIS Component Category Registrar support
            ArcGISCategoryUnregistration(registerType);

            //
            // TODO: Add any COM unregistration code here
            //
        }

        #region ArcGIS Component Category Registrar generated code
        ///
        /// Required method for ArcGIS Component Category registration -
        /// Do not modify the contents of this method with the code editor.
        ///
        private static void ArcGISCategoryRegistration(Type registerType)
        {
            string regKey = string.Format("HKEY_CLASSES_ROOT\\CLSID\\{{{0}}}", registerType.GUID);
            MxCommandBars.Register(regKey);
        }
        ///
        /// Required method for ArcGIS Component Category unregistration -
        /// Do not modify the contents of this method with the code editor.
        ///
        private static void ArcGISCategoryUnregistration(Type registerType)
        {
            string regKey = string.Format("HKEY_CLASSES_ROOT\\CLSID\\{{{0}}}", registerType.GUID);
            MxCommandBars.Unregister(regKey);
        }

        #endregion
        #endregion

        public HelloWorldToolbar()
        {
            //
            // TODO: Define your toolbar here by adding items
            //
            //AddItem("esriArcMapUI.ZoomInTool");
            //BeginGroup(); //Separator
            //AddItem("{FBF8C3FB-0480-11D2-8D21-080009EE4E51}", 1); //undo command
            //AddItem(new Guid("FBF8C3FB-0480-11D2-8D21-080009EE4E51"), 2); //redo command
        }

        public override string Caption
        {
            get
            {
                //TODO: Replace bar caption
                return "My C# Toolbar";
            }
        }
        public override string Name
        {
            get
            {
                //TODO: Replace bar ID
                return "HelloWorldToolbar";
            }
        }
    }
}

Vamos lá:

O que merece nota imediata:

• O construtor da barra de ferramentas. O construtor é o método responsável por instanciar um novo objeto do tipo HelloWorldToolbar. Veja que existem um monte de comentários ensinando como podemos inserir ferramentas ou botões nele. À seguir utilizaremos eles. Mas dê uma lida nos comments com carinho.
• A propriedade Caption. Nela temos "My C# Toolbar" como caption. Altere para o que achar melhor. Este nome é o nome que irá aparecer dentro do ArcGIS.
• A propriedade Name. Deve ser único. Portanto, é melhor nem mexer com isto, por enquanto.
• O restante são funções para registro/desregistro da barra de ferramentas. Isto é um pré-requisito, pois estamos trabalhando com tecnologia COM, se lembram? Não altere nada.

Nossa barra de ferramentas está criada, mas uma barra de ferramentas sozinha não me adianta de nada. Vamos criar umas ferramentinhas. Siga o mesmo procedimento que utilizou para criar a barra de ferramentas, mas desta vez, escolha BaseCommand e nomeie ele como achar melhor. No meu caso, vou dar o nome de ComandoHelloWorld.

Mais uma vez um prompt irá aparecer e te perguntar qual é o tipo de comando você quer criar. Vejamos...escolha Desktop ArcMap Command e boa.

using System;
using System.Drawing;
using System.Runtime.InteropServices;
using ESRI.ArcGIS.ADF.BaseClasses;
using ESRI.ArcGIS.ADF.CATIDs;
using ESRI.ArcGIS.Framework;
using ESRI.ArcGIS.ArcMapUI;

namespace HelloWorldArcGIS
{
    ///
    /// Summary description for ComandoHelloWorld.
    ///
    // preste atenção neste valor aqui!
    [Guid("2423ecdf-4f14-4993-a165-df9d79167f4d")]
    // preste atenção neste valor aqui!
    [ClassInterface(ClassInterfaceType.None)]
    [ProgId("HelloWorldArcGIS.ComandoHelloWorld")]
    public sealed class ComandoHelloWorld : BaseCommand
    {
        #region COM Registration Function(s)
        [ComRegisterFunction()]
        [ComVisible(false)]
        static void RegisterFunction(Type registerType)
        {
            // Required for ArcGIS Component Category Registrar support
            ArcGISCategoryRegistration(registerType);

            //
            // TODO: Add any COM registration code here
            //
        }

        [ComUnregisterFunction()]
        [ComVisible(false)]
        static void UnregisterFunction(Type registerType)
        {
            // Required for ArcGIS Component Category Registrar support
            ArcGISCategoryUnregistration(registerType);

            //
            // TODO: Add any COM unregistration code here
            //
        }

        #region ArcGIS Component Category Registrar generated code
        ///
        /// Required method for ArcGIS Component Category registration -
        /// Do not modify the contents of this method with the code editor.
        ///
        private static void ArcGISCategoryRegistration(Type registerType)
        {
            string regKey = string.Format("HKEY_CLASSES_ROOT\\CLSID\\{{{0}}}", registerType.GUID);
            MxCommands.Register(regKey);

        }
        ///
        /// Required method for ArcGIS Component Category unregistration -
        /// Do not modify the contents of this method with the code editor.
        ///
        private static void ArcGISCategoryUnregistration(Type registerType)
        {
            string regKey = string.Format("HKEY_CLASSES_ROOT\\CLSID\\{{{0}}}", registerType.GUID);
            MxCommands.Unregister(regKey);

        }

        #endregion
        #endregion

        private IApplication m_application;
        public ComandoHelloWorld()
        {
            //
            // TODO: Define values for the public properties
            //
            base.m_category = ""; //localizable text
            base.m_caption = "";  //localizable text
            base.m_message = "";  //localizable text
            base.m_toolTip = "";  //localizable text
            base.m_name = "";   //unique id, non-localizable (e.g. "MyCategory_ArcMapCommand")

            try
            {
                //
                // TODO: change bitmap name if necessary
                //
                string bitmapResourceName = GetType().Name + ".bmp";
                base.m_bitmap = new Bitmap(GetType(), bitmapResourceName);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.WriteLine(ex.Message, "Invalid Bitmap");
            }
        }

        #region Overriden Class Methods

        ///
        /// Occurs when this command is created
        ///
        ///
        Instance of the application
        public override void OnCreate(object hook)
        {
            if (hook == null)
                return;

            m_application = hook as IApplication;

            //Disable if it is not ArcMap
            if (hook is IMxApplication)
                base.m_enabled = true;
            else
                base.m_enabled = false;

            // TODO:  Add other initialization code
        }

        ///
        /// Occurs when this command is clicked
        ///
        public override void OnClick()
        {
            // TODO: Add ComandoHelloWorld.OnClick implementation
        }

        #endregion
    }
}

Pontos merecedores de notas:

• Novamente o construtor do comando. Ele tem diversas informações que são mostradas ao usuário no ArcGIS. Não irei explicar uma à uma, brinque com elas e teste.
• Um campo (field) importantissímo: m_application. Ele guarda uma referência de memória à sua aplicação que está rodando. Sem o software não teria como chamar coisas que estão lá dentro.
• Método OnClick(). Este método é que irá rodar quando o usuário clicar no comando. Nós implementaremos as coisinhas todas ali. Capiche?

Vamos adicionar nosso comando à barra de ferramentas. Lembram do construtor da barra de ferramentas, que contém alguns exemplos de Add?

Vá no seu comando e procure pelo valor GUID dele. O meu é 2423ecdf-4f14-4993-a165-df9d79167f4d. Digite isto (claro, com o seu valor GUID) no construtor da barra de ferramentas.

    AddItem(new Guid("2423ecdf-4f14-4993-a165-df9d79167f4d"), 0);

Vamos tentar compilar. Aperte F6.

Um erro deve aparecer. Ainda não configuramos nossa aplicação para abrir com o ArcMap. Vá na raiz do projeto, clique com o botão direito e vá em Properties.

Você irá ver um monte de coisas.

Na parte de Application procure Output Type e escolha Class Library.

Em Build marque a última opção, Register for COM Interop. Lembra que tudo que fazemos com ArcObjects temos que fazer com COM? Ficou estranho isso, mas válá.

Vá em DEBUG e procure a seção Start Action. Marque Start External Program e localize o arquivo ArcMap.exe no seu computador. O meu fica em C:\Program Files\ArcGIS\bin\ArcMap.exe.

Tente compilar novamente. Aperte F6. Você não deve ver nenhum erro. O ArcGIS irá abrir sozinho.

ArcGIS aberto e barra de ferramenta disponível

Nossa barrinha de ferramentas esta lá!

Agora vamos implementar a nossa super-ultra-mega-complexa funcionalidade. Feche o ArcMap. Retorne ao Visual Studio.

Abra o arquivo de código do nosso comando. Suba até o topo de nosso arquivo.

Você verá um monte de coisas como using System.Drawing entre outros. Aqui nós dizemos ao Visual Studio quais assemblies este arquivo poderá acessar. Faltam duas importantes para nós aí.

Insira a assembly ESRI.ArcGIS.Carto e a assembly System.Windows.Forms. Lembre-se de colocar cada uma em uma linha, e não se esqueça do ponto-e-vírgula.

        public override void OnClick()
        {
            // pegue uma referência ao documento que está rodando
            // note o uso do campo m_application
            IMxDocument documento = (IMxDocument)this.m_application.Document;

            // pegue uma referência ao mapa atual
            // note que caso tenha múltiplos data-frames isto pode não funcionar como esperado...
            IMap mapa = documento.FocusMap;

            // vamos contar quantas camadas temos no nosso mapa?
            Int32 numeroCamadas = mapa.LayerCount;

            // me diga quantas camadas eu tenho!
            MessageBox.Show("Temos neste mapa " + numeroCamadas.ToString() + " camadas!");
        }

Altere sua função OnClick nestes termos. Não copie e cole. Tente entender o que está acontencendo dentro do código. Digite linha por linha. Porque? Porque faz bem e o Visual Studio ainda irá mostrar para vocês a jóia de sua coroa, o Intellisense. Ele te sugere o que você pode estar precisando. Você conseguirá enxergar diversos atributos e propriedades de cada uma destas classes.

Tem bastante coisa interessante só nessas três classezinhas. Navegue. Use o EDN. Use o Help (F1). E poste suas dúvidas.

Bem, agora é com vocês. Me digam o que acharam. Foi difícil? À princípio vai ser difícil sim! Como meu bom e velho avô diz: rapadura é doce mas não é mole não!

Estou no aguardo das dúvidas, comentários e blasfêmias!

Espero que tenham gostado,

Um abraço,

George R. C. Silva

Related posts:

1. Diquinhas de ArcGIS #1
2. Brincando com ArcObjects
3. ArcGIS.com lançado

Mais uma vez venho a vocês com uma futura série de pequenos artigos, desta vez sobre ArcObjects, a API da ESRI para o desenvolvimento de funções que levam em conta o espaço e dados espaciais.

Bem, primeiramente devemos começar dizendo que ArcObjects não é um bicho de sete cabeças, é um bicho só de cinco. Não é nada complicado, quando você entende o que quer fazer e onde procurar.

Para quem está perdido, API é um conjunto de rotinas e funcionalidades já escritas que pode-se extender, através de programação. Ou seja, ArcObjects é essencialmente os blocos construtivos do software ArcGIS. Os caras na ESRI desenvolvem o ArcObjects e depois o usam para montar o ArcMap, por exemplo.

E realmente são muitos blocos. A API é composta (hoje, na versão 9.3) por quatro mil classes, cinco mil interfaces, mais de mil enumerações e cinquenta structs, isso sem contar os tipos escondidos e restritos!

Certo e o que mais precisamos saber sobre a API ArcObjects para começar a programar para o ArcGIS? Nada, na realidade, mas existem alguns conceitos que devem ser conhecidos.  Toda a API foi desenvolvida seguindo o modelo COM (Component Object Model), o padrão para distribuição de bibliotecas binárias em ambiente desktop, desenvolvido pela Microsoft.

E isto muda tudo. A tecnologia COM estabelece padrões e exige alguns requisitos para que um software seja COM-compatible. Finalmente, devemos entender que COM é uma arquitetura, uma forma de desenvolver software.

A arquitetura COM é baseada em servidores e clientes. O servidor, ou o objeto, dá uma funcionalidade e o cliente a utiliza. Para facilitar ainda mais, um servidor pode ser um cliente e vice-versa. A arquitetura COM facilita a comunicação entre estes dois processos (servidor/cliente). Existem muitas particularidades da tecnologia, que realmente não cabem no escopo deste post, mas todos devem ficar de olho nisto, pois software mal desenvolvido que utiliza COM é software que um dia irá explodir. Esta arquitetura tem sérios problemas de perfomance e coleta de lixo.

Para saber mais, visite esta página e esta página.

Certo, o que podemos fazer com ArcObjects? Tudo o que podemos fazer dentro do ArcGIS, podemos fazer utilizando ArcObjects. Tudo e muito mais, claro. Como o próprio ArcGIS foi construído sobre ArcObjects, estamos na realidade falando de uma coisa só!

O que preciso para desenvolver em ArcObjects?

Bem, a API está implementada em uma porção de linguagens, sendo possível utilizar qualquer uma e realizar as mesmas tarefas. As linguagens suportadas são: VC++ (Visual C++), C# (minha favorita), VB.NET, Java e até VBA (cuidado, o suporte para VBA ACABOU!).

Não existe melhor ou pior, apenas diferente . Caso você tenha experiência com uma ou outra, sugiro que comece pela linguagem que tem maior familiaridade, mas um aviso: existem tendências e a tendência é .NET (C# principalmente).

Após escolher sua linguagem de preferência, instale um IDE (Integrated Development Environment - como o Visual Studio, no caso de .NET) e instale as bibliotecas que veêm com o ArcGIS. Note que as bibliotecas já estão no CD de instalação do ArcGIS Desktop (as bibliotecas de programação para Desktop, claro).

Primeiro instale o ambiente de desenvolvimento e depois a biblioteca. Nunca o contrário.

Tela de Instalação dos SDK's ArcGIS Desktop

Depois que tudo estiver instalado, sugiro que passe um tempo se familiarizando com cada IDE e com a referência oficial da ESRI. Ache um pequeno problema que lhe incomoda no ArcGIS (algo que poderia ser mais fácil, ou poderia ser diferente e facilitaria seu trabalho - imagino que existem diversas coisas) e tente criar alguma coisa em ArcObjects para isto.

Como são muitas classes e interfaces, não se preocupe em conhecer todas, se preocupe em conhecer como achar na referência oficial dados sobre determinada classe/interface.

Aviso aos navegantes: é muito comum em ArcObjects você ter de instaciar dois, três ou quatro objetos para fazer uma coisinha simples (como é o caso das interfaces IFields e IFieldsEdit, IField e IFieldEdit, entre outras).

Os namespaces mais utilizados, provavelmente são esriSystem, ArcMap, ArcMapUI, Geometry e Geodatabase. Todos tem sua própria página na ESRI, incluindo um diagrama completo do mesmo.

Caso tenham dúvidas, estamos aqui! Próximo post: Hello World, ArcGIS style!

Abraços

George

Related posts:

1. Máquina Virtual e Desenvolvimento para ArcObjects
2. Brincando com ArcObjects
3. ArcObjects e Class Extensions #1