Sectores Productivos
| Proyecto: | Mapa Productivo de Venezuela- Sistema de Información Geográfico |
| Actividad: | Definición de Producción por Sectores |
| Responsable: | Erwin Paredes |
| Fecha de Culminación: | 25/04/2014 |
| Porcentaje asignado: | 15% |
| Porcentaje de avance: | 15% |
Descripción:
Investigar y desarrollar la funcionalidad para ilustrar sobre el mapa de Venezuela, la ubicación de las Unidades Económicas que se encuentran registradas en el Sistema de Información SIGESIC, según la clasificación de los diversos sectores productivos y organizados por capas por distribución geográfica específicos en los requerimientos donde se establecen las zonas de estudio.
Productos a obtener:
- Informe de análisis sobre la funcionalidad
- Caso de Uso y diagrama de Estados
- Investigación sobre las librerías en software libre disponible para desarrollar la funcionalidad
- Desarrollo de la funcionalidad anexándola al desarrollo del proyecto.
Resultados obtenidos:
Informe de análisis sobre la funcionalidad: En el documento con el título sectores_productivos en formato .odt el cual contiene:
- La clasificación y descripción de los sectores productivos estipulados para el estudio.
- Clasificación de los sectores productivos en el marco de las leyes venezolanas:
- Constitución Nacional de la República Bolivariana de Venezuela.
- Plan de la Patria 2013-2019.
- Decreto de las Regiones Estratégicas de Desarrollo Integral (REDI)
- Consejo Federal de Gobierno - Unidades de Gestión Territorial.
- Zonas Económicas Especiales.
- Clasificación Industrial Internacional Uniforme (CIIU -Rev.4), adaptación al país por medio del Clasificador de Actividades Económicas Venezolano (CAEV)
- Tabla de Clasificador de actividades económicas venezolano y sectores productivos
- Requerimientos para el sistema del módulo Sectores Productivos en el Sistema de Información Geográfico - Mapa Productivo Venezolano.
Se presentó el documento inicial, a los integrantes del grupo, el día 11/02/2014, posteriormente se realizó una reunión donde se propuso modificaciones que se incorporaron el 19/02/2014, quedando la versión final.
Casos de Uso y diagramas de Estado:
Se utilizó la herramienta colaborativa denominada Cacoo, la cual es un componente que se adiciona al navegador google chrome y se viene utilizando en el desarrollo del proyecto. Se anexa el documento con los diagramas correspondientes. Se anexa el archivo https://miv.cenditel.gob.ve/sig/attachment/wiki/Sectores%20Productivos/Caso_de_Uso_Sectores_Productivos.pdf|Casos_de_Uso_Sectores_Productivos.pdf
Investigación sobre las librerías en software libre:
Siguiendo los lineamientos en el desarrollo de la primera etapa del sistema se inicia la investigación sobre las librerias OpenLayers? en la versión 2.13 y el servidor de mapas Open Street Map, así como el manejo de objectos almacenados bajo el formato GeoJson?, con el manejo de librerías en el lenguaje de programación JavaScritp?; los cuales ya se encuentran disponibles según la división territorial del país, desde el nivel de los Estados, sus municipios y parroquias.
Se anexa a continuación el código fuente producto de la investigación y una pantalla con el resultado mostrada en el navegador, en el archivo sectores_productivos_vzla_html.pdf
Archivo: sectores_productivos_vzla.html
<!DOCTYPE html> `
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" >
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
<meta name="apple-mobile-web-app-capable" content="yes">
<title>Sectores Productivos - Mapa de Venezuela</title>
<link rel="stylesheet" href="../theme/default/style.css" type="text/css">
<link rel="stylesheet" href="style.css" type="text/css">
<style type="text/css">
.olControlAttribution {
left: 2px;
right: inherit;
bottom: 3px; `
line-height: 11px;
}
.map {
height: 400px; width: 100%;
}
</style>
</head>
<body>
<h1 id="title">Mapa de Venezuela</h1>
<div id="tags">
geojson, bing, projection
</div>
<div id="shortdesc">Capas de dispersión</div>
<div id="map" class="mediomap"></div>
<div id="docs">
<p>Leyenda:
<a target="_blank" href=""></a>
</p>
</div>
<script src="../lib/OpenLayers.js"></script>
<script src="geojson-reprojected_vzla.js"></script>
</body>
</html>
Archivo: geojson-reprojected_vzla.js
/* Inicio del Código */
// API key for http://openlayers.org. Please get your own at
// http://bingmapsportal.com/ and use that instead.
var apiKey = "AqTGBsziZHIJYYxgivLBf0hVdrAk9mWO5cQcb8Yux8sW5M8c8opEC2lZqKR1ZZXf";
var lat=6.5000;
var lon=-65.0000;
var zoom=7;
var hybrid = new OpenLayers.Layer.OSM("Venezuela");
var lonLat = new OpenLayers.LonLat(lon, lat).transform(new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913"));
var vector = new OpenLayers.Layer.Vector("GeoJSON", {
projection: "EPSG:4326",
style: {
fill: true,fillColor: "#000080",
strokeColor: "#ff00ff",
strokeWidth: 3,
fillOpacity: 0.4,
cursor: "pointer"
},
strategies: [new OpenLayers.Strategy.Fixed()],
protocol: new OpenLayers.Protocol.HTTP({
url: "14.geojson",
format: new OpenLayers.Format.GeoJSON()
})
});
var vector2 = new OpenLayers.Layer.Vector("GeoJSON", {
projection: "EPSG:4326",
style: {
fill: true,fillColor: "#006400",
strokeColor: "#ff00ff",
strokeWidth: 3,
fillOpacity: 0.4,
cursor: "pointer"
},
strategies: [new OpenLayers.Strategy.Fixed()], `
protocol: new OpenLayers.Protocol.HTTP({ `
url: "20.geojson", `
format: new OpenLayers.Format.GeoJSON() `
})
});
var vectores = [hybrid, vector, vector2];
var center = new OpenLayers.LonLat(-71.0753, 8.6255).transform("EPSG:4326", "EPSG:900913");
var map = new OpenLayers.Map({
div: "map",
layers: vectores,
center: center,
zoom: 7
});
map.setCenter (lonLat, zoom);
/* Fin del Código */
Los archivos accesados por los identificadores url como atributos del objeto Vertor de la clase Layers de la librería Openlayers, identificados con los nombre 14.geojson y 20.geojson contiene la poligonal georeferencial de los estados Táchira y Mérida.
Lo que resta por realizar:
Se debe incorporar toda la investigación y análisis realizado al sistema, anexando un módulo dentro del proyecto, que se encuentra desarrollado con la herramienta django del lenguaje de programación python.
| Observación | Responsable | Fecha |
| Documento Inicial | Erwin Paredes | 26/02/2014 |
Django + Geo_Django + Postgis
Almacén de datos georeferenciales y el manejo para la representación en el Mapa de OSM con librerías OpenLayers
Se cuenta con archivo de texto plano con formato GeoJson, que representa la Multipoligonal de las fronteras de las regiones dividas según la distribución federal territorial
Para se creo una Base de Datos denominada geodb en Postgresql 9.3 el cual se tiene instalado el componente de Postgis correspondiente a la versión, donde se creará al tabla que contienen los datos tipo json, en primer lugar se debe pasar al formato shapefile, extensión .shp, para poder utilizar los recursos de almacenamiento desde archivos. Desde un terminal de comandos se debe ejecutar las siguientes instrucciones:
ogr2ogr archivodesalida.shp -f "ESRI Shapefile" archivo.geojson
Luego, se puede instar en el archivo en la base de datos:
shp2pgsql -s 4326 archivo.shp estado | psql -d geodb -U administrador -h localhost
Esta instrucción crea la tabla estado en la base de datos y anexa un registro con los datos y su correspondiente columna de datos que contiene la geometría
Se debe anexar el parametro -a para seguir anexando nuevo registro y no sobrescribir la tabla. En caso de no haber creado la base de datos se detallan las instrucciones a continuación:
Instalación de Postgres 9.3
Anexar el repositorio a source.list:
nano /etc/apt/sources.list.d/pgdg.list
Añadir la línea
deb http://apt.postgresql.org/pub/repos/apt/ wheezy-pgdg main
Salvar y obtener la llave de seguridad:
wget https://www.postgresql.org/media/keys/ACCC4CF8.asc|https://www.postgresql.org/media/keys/ACCC4CF8.asc apt-key add ACCC4CF8.asc
Actualizar el banco de repositorios:
apt-get update
Ojo: recordar el respaldo de las bases de datos anteriores...
apt-get install postgresql-9.3 pgadmin3 postgis postgresql-contrib-9.3
En pgadmin3:
Crear base de datos espacial:
-- Enable PostGIS (includes raster) CREATE EXTENSION postgis; -- Enable Topology CREATE EXTENSION postgis_topology; -- fuzzy matching needed for Tiger CREATE EXTENSION fuzzystrmatch; -- Enable US Tiger Geocoder CREATE EXTENSION postgis_tiger_geocoder;
Crear la base de datos geodb.
Django:
Se deben instalar los sigueintes componentes que manejan las librerias de acceso para datos GeoJson:
pip install django-geojson pip install django-leaflet
Crear un proyecto en Django y una aplicación en este caso se denominan geodjango y estado respectivamente
Configurar la conexión a la base de datos y las aplicaciones instaladas en el archivo settings.py
A continuación los archivos que realizan la consulta y su respectiva salida:
urls.py
from django.conf.urls import patterns, include, url
from django.conf import settings
import os
from djgeojson.views import GeoJSONLayerView
from estado.models import estado
# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()
urlpatterns = patterns(''}}},
# Examples:
# url(r'^$', 'geodjango.views.home', name='home'),
# url(r'^geodjango/', include('geodjango.foo.urls')),
url(r'^estado/', include('estado.urls')),
url(r'^data.geojson$', GeoJSONLayerView.as_view(model=estado), name='data'),
# Uncomment the admin/doc line below to enable admin documentation:
# url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
# Uncomment the next line to enable the admin:
# url(r'^}}}admin/', include(admin.site.urls)),
)
if settings.DEBUG:
urlpatterns += patterns(''}}},
(r'^media/(?P<path>.*)$', 'django.views.static.serve', {'document_root': os.path.join(os.path.dirname(__file__), "media")}),
(r'^static/(?P<path>.*)$', 'django.views.static.serve', {'document_root': os.path.join(os.path.dirname(__file__), "static")}),
)
urls.py en la aplicación estado
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from django.conf.urls.defaults import *
urlpatterns = patterns(''}}},
url(r'^$', 'estado.views.estados', name='Estados'),
url(r'^mapa?$', 'estado.views.mapa', name='Mapa'),
url(r'^json?$', 'estado.views.json', name='Mapa'),
)
view.py
from django.shortcuts import *
from django.contrib.auth.decorators import login_required
from django.template.context import Context, RequestContext
from django.template import Template,loader
from django.core.context_processors import csrf
from django import forms
from django.contrib.gis.geos import GEOSGeometry
from estado.forms import *
from djgeojson.serializers import Serializer as GeoJSONSerializer
from django.utils import simplejson
from estado.models import estado
def estados(request):
formu = FormularioEstado()
return render_to_response('estado/estados.html',{'FormularioEstado':formu}, context_instance = RequestContext(request))
def mapa(request):
formu = FormularioEstado(request.POST)
if formu.is_valid():
est = formu.clean_estado()
estados = simplejson.dumps(est)
c = {}
c.update(csrf(request))
formu = FormularioEstado()
return render_to_response('geojson_mapa.html',{'FormularioEstado':formu, 'estados':estados}, context_instance = RequestContext(request))
def json(request):
cod_est = request.GET['cod_estado']
qs = estado.objects.get(cod_estado=cod_est)
qa=GeoJSONSerializer().serialize(estado.objects.filter(estado=qs.estado), use_natural_keys=True)
return HttpResponse(str(qa), content_type="text/plain")
forms.py
# -*- coding: utf-8 -*-
from django import forms
from django.forms.widgets import CheckboxSelectMultiple, SelectMultiple
from estado.models import estado
def cargarEstado():
consulta = estado.objects.all().order_by('estado')
lista = [(p.cod_estado, p.estado ) for p in consulta]
return lista
class FormularioEstado(forms.Form):
error_css_class = 'error'
required_css_class = 'error'
estado = forms.MultipleChoiceField(choices=cargarEstado(), required=True, widget= CheckboxSelectMultiple(attrs={'title': 'Estados','size':cargarEstado().{{{{{{}}}__}}}len{{{{{{}}}__}}}(), 'class':'field select'}), label= 'Estados');
def clean_estado(self):
res= self.cleaned_data['estado']
cleaned_data = self.cleaned_data
if res=='0':
raise forms.ValidationError(_(u"Debe seleccionar una opción"))
return res
base_formulario.html
{% load i18n %}
{% load l10n %}
<!DOCTYPE html>
<html lang="es">
<head>
<title>{% trans "titulo_pagina" %}</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<link rel="stylesheet" href="/media/css/style.css" type="text/css" media="screen"/>
<script type="text/javascript" src="/media/js/jquery.min.js"></script>
<script src="/media/js/kickstart.js"></script> <!-- KICKSTART -->
<link rel="stylesheet" href="/media/css/kickstart.css" media="all" /> <!-- KICKSTART -->
{% block librerias %}
{% endblock librerias %}
</head>
<body>
{% block formulario %}
{% endblock formulario%}
</body>
</html>
estado.html
{% extends "base_formulario.html" %}
{% block formulario %}
<form action="mapa" method="post"> {% csrf_token %}
<h3 id="forms">Formulario</h3>
<fieldset>
<legend>Estados</legend>
{{ FormularioEstado.estado }}
</fieldset>
<hr />
<button class="blue">Ejecutar</button>
</form>
{% endblock formulario %}
geojson_mapa.html
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" >
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
<meta name="apple-mobile-web-app-capable" content="yes">
<title>Mapa de Venezuela</title>
<link rel="stylesheet" href="../media/theme/default/style.css" type="text/css">
<link rel="stylesheet" href="../media/style.css" type="text/css">
<style type="text/css">
.olControlAttribution {
left: 2px;
right: inherit;
bottom: 3px;
line-height: 11px;
}
.map {
height: 400px; width: 100%;
}
</style>
</head>
<body>
<h1 id="title">Mapa de Venezuela</h1>
<div id="tags">
Sectores productivos
</div>
<div id="shortdesc">Mapa</div>
<div id="map" class="mediomap"></div>
<div id="docs">
<p>Leyenda:</p>
</div>
<script src="../media/lib/OpenLayers.js"></script>
<script type="text/javascript">
var est = {{estados|safe}};
var estados = new Array(est.length-1);
for (var i=0;i<est.length;i++)
{
estados[i]="http://localhost:8000/estado/json?cod_estado="+est[i];
}
var apiKey = "AqTGBsziZHIJYYxgivLBf0hVdrAk9mWO5cQcb8Yux8sW5M8c8opEC2lZqKR1ZZXf";
var lat=6.5000;
var lon=-65.0000;
var zoom=7;
var hybrid = new OpenLayers.Layer.OSM("Venezuela");
var lonLat = new OpenLayers.LonLat(lon, lat).transform(new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913"));
//var estados = ["http://localhost:8000/estado/json?cod_estado=20","http://localhost:8000/estado/json?cod_estado=14","http://localhost:8000/estado/json?cod_estado=02"];
var colores = ["#B42BCC","#002BCC","#2BCC43"];
var vectores = new Array(est.length-1);
vectores[0] = hybrid;
for (var i=0;i<estados.length;i++)
{
vectores[i+1] = new OpenLayers.Layer.Vector("GeoJSON", {
projection: "EPSG:4326",
style: {
fill: true,fillColor: colores[i],
strokeColor: "#ff00ff",
strokeWidth: 3,
fillOpacity: 0.4,
cursor: "pointer"
},
strategies: [new OpenLayers.Strategy.Fixed()],
protocol: new OpenLayers.Protocol.HTTP({
url: estados[i],
format: new OpenLayers.Format.GeoJSON()
})
});
}
var center = new OpenLayers.LonLat(-71.0753, 8.6255).transform("EPSG:4326", "EPSG:900913");
var map = new OpenLayers.Map({
div: "map",
layers: vectores,
center: center,
zoom: 7
});
map.setCenter (lonLat, zoom);
</script>
</body>
</html>
Ejecutar el sistema desde la linea de comandos:
python manages.py runserver
en un navegador: localhost:8000/estado
Al seleccionar el estado y presionar el botón ejecutar:
El formulario se crea de forma dinámica desde la base de datos:
Cabe destacar que la filosofía empleada es tener un mapa de densidad por regiones parametrizadas, esto es, se debe seleccionar una gama de colores que se requieran implementar y así poder representar cualquier dato en comparación con degradado de colores.
Lo que queda, es realizar el módulo de Sectores productivos, según requerimientos del usuario, basado en toda la investigación que acá se relata.
| Observación | Responsable | Fecha |
| Continuación | Erwin Paredes | 04/04/2014 |
Sistema de Información Geográfico - Conexión con Base de Datos Sigesic
En el avance del módulo de los Sectores Productivos en su representación geográfica por medio de mapas de densidad, se realiza una conexión con la Base de Datos del sistema Sigesic, el cual provee una fuente de datos que recoge la información suministrada por las Unidades Económicas del país.
Dada la versatilidad de la herramienta que permite la conexión con diversas bases de datos se configura dicha conexión en el archivo settings.py, para su posterior utilización:
DATABASES = {
'default': {
'ENGINE': 'django.contrib.gis.db.backends.postgis', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
'NAME': 'geodb', # Or path to database file if using sqlite3.
'USER': 'administrador', # Not used with sqlite3.
'PASSWORD': 'clave', # Not used with sqlite3.
'HOST': 'localhost', # Set to empty string for localhost. Not used with sqlite3.
'PORT': '5432', # Set to empty string for default. Not used with sqlite3.
},
'sigesic': {
'ENGINE': 'django.db.backends.postgresql_psycopg2', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
'NAME': 'sigesic_03162014', # Or path to database file if using sqlite3.
'USER': 'administrador', # Not used with sqlite3.
'PASSWORD': 'clave', # Not used with sqlite3.
'HOST': 'localhost', # Set to empty string for localhost. Not used with sqlite3.
'PORT': '5432', # Set to empty string for default. Not used with sqlite3.
}
}
Por diseño destacamos la utilización de la base de datos denominada geodb, cuyo motor funciona con la librería de postgis, en ella contiene los datos geométricos de las regiones y almacena la gama de colores que se utilizan para representar la densidad en el mapa.
Para el acceso a datos de la información contenida en la base de datos del Sigesic, se utiliza un cursor que almacena la consulta a las tablas referidas por medio de la ejecución de una sentencia SQL, establecida en las vistas correspondientes, en este primer caso se realiza un extraen los datos de la tabla comun_codigo_ciiu, la cual contiene los código a 4 dígitos, así como su respectiva descripción, la cual es transformada en la estructura de datos tipo diccionario para su visualización en el template correspondiente. Como se muestra a continuación en el archivo estados/views.py:
def dictfetchall(cursor):
"Returns all rows from a cursor as a dict"
desc = cursor.description
return [
dict(zip([col[0] for col in desc], row))
for row in cursor.fetchall()
]
def estados(request):
formu = FormularioEstado()
cursor = connections['sigesic'].cursor()
cursor.execute("select codigo,descripcion from comun_codigo_ciiu where length(codigo)=4 order by codigo")
ciiu = dictfetchall(cursor)
return render_to_response('estado/estados.html',{'FormularioEstado':formu,'ciiu':ciiu}, context_instance = RequestContext(request))
Pantalla del sistema en la Web:
Nota: El icono al inicio de la página es solo referencial, en espera del diseño definitivo.
El usuario debe seleccionar la actividad deferencia por el código CIIU y los estados o municipios a consultar, y presionar el botón ejecutar, el cual realiza la consulta igualmente sobre la cantidad de Unidades Económicas presentes en la base de datos del Sigesic, que cumplen con la condición y la organiza por regiones, se bueno destacar que en los datos del Sigesic se encuentra almacenado a nivel de parroquias la ubicación de las mismas, por medio de un código establecido y no de forma georeferenciada.
Acá el código que ejecuta dicha consulta en el archivo views.py:
def mapa(request):
formu = FormularioEstado(request.POST)
if formu.is_valid():
est = formu.clean_estado()
ciiu = request.POST['ciiu']
seleccion = "select substring(parroquia_codigo from 1 for 2) as estado, count(*) as cantidad from unidadecon_subunidad_economica where ue_rif in (select unidad_economica_rif from unidadecon_actividad_ciiu where ciiu_id = '"+ciiu+"') group by substring(parroquia_codigo from 1 for 2) order by cantidad DESC"
#select parroquia_codigo from unidadecon_unidad_economica where rif in (select unidad_economica_rif from unidadecon_actividad_ciiu where ciiu_id = '"+ciiu+"')"
cursor = connections['sigesic'].cursor()
cursor.execute(seleccion)
resultado = dictfetchall(cursor)
consulta = estado.objects.filter(cod_estado__in = est).order_by("estado")
nombres = [{'localidad': p.estado, 'codigo': p.cod_estado} for p in consulta]
centros_x = [p.geom.centroid.get_x() for p in consulta]
centros_y = [p.geom.centroid.get_y() for p in consulta]
colores = [p.color.replace('#',''}}}) for p in color.objects.all().order_by('color')]
vcol = []
for p in nombres:
esta = '0'
colr = colores[len(colores)-1]
i=-1
for c in resultado:
i+=1
if p['codigo'] == c['estado']:
esta = c['cantidad']
if i > (len(colores)-1):
i=0
colr = colores[i]
p.update({'color':colr, 'valor': esta})
vcol.append(colr)
estados = simplejson.dumps(est)
else:
cursor = connections['sigesic'].cursor()
cursor.execute("select codigo,descripcion from comun_codigo_ciiu where length(codigo)=4 order by codigo")
ciiu = dictfetchall(cursor)
return render_to_response('estado/estados.html',{'FormularioEstado':formu,'ciiu':ciiu}, context_instance = RequestContext(request))
c = {}
c.update(csrf(request))
formu = FormularioEstado()
return render_to_response('geojson_mapa.html',{'FormularioEstado':formu, 'zonas':estados,'division':'estado','nombres':nombres,'colores':simplejson.dumps(vcol),'centros_x':centros_x,'centros_y':centros_y,'c':c}, context_instance = RequestContext(request))
Igualmente podemos destacar el uso de las librerías que provee el Geodjango para realizar operaciones con los geometrías de las regiones, siendo así que permite calcular los centroides de las zonas.
El script en el template queda así codificado:
<script type="text/javascript">
var est = {{zonas|safe}};
var vcol = {{colores|safe}};
var centros_x = {{centros_x}};
var centros_y = {{centros_y}};
var estados = new Array(est.length-1);
var colore = new Array(est.length-1);
for (var i=0;i<est.length;i++)
{
estados[i]="{{BASE_URL}}/{{division}}/json?cod_poli="+est[i];
colore[i] = "#"+vcol[i];
}
var apiKey = "AqTGBsziZHIJYYxgivLBf0hVdrAk9mWO5cQcb8Yux8sW5M8c8opEC2lZqKR1ZZXf";
var lat=6.5000;
var lon=-65.0000;
var zoom=7;
var hybrid = new OpenLayers.Layer.OSM("Venezuela");
var lonLat = new OpenLayers.LonLat(lon, lat).transform(new OpenLayers.Projection("EPSG:4326"), new OpenLayers.Projection("EPSG:900913"));
var vectores = new Array(est.length-1);
vectores[0] = hybrid;
var j = 0;
for (var i=0;i<estados.length;i++)
{
vectores[i+1] = new OpenLayers.Layer.Vector("GeoJSON", {
projection: "EPSG:4326",
style: {
fill: true,fillColor: colore[j],
strokeColor: "#ff00ff",
strokeWidth: 3,
fillOpacity: 0.4,
cursor: "pointer"
},
strategies: [new OpenLayers.Strategy.Fixed()],
protocol: new OpenLayers.Protocol.HTTP({
url: estados[i],
format: new OpenLayers.Format.GeoJSON()
})
});
if (j==14){j=-1;}
j +=1;
}
var center = new OpenLayers.LonLat(-71.0753, 8.6255).transform("EPSG:4326", "EPSG:900913");
var map = new OpenLayers.Map({
div: "map",
layers: vectores,
center: center,
zoom: 7
});
var markers = new OpenLayers.Layer.Markers( "Markers" );
map.addLayer(markers);
var size = new OpenLayers.Size(21,25);
var offset = new OpenLayers.Pixel(-(size.w/2), -size.h);
//var icon = new OpenLayers.Icon('http://www.openlayers.org/dev/img/marker.png', size, offset);
var icon = new OpenLayers.Icon('{{MEDIA_URL}}/map_icons/pin5.png', size, offset);
for (var i=0;i<estados.length;i++)
{
markers.addMarker(new OpenLayers.Marker(new OpenLayers.LonLat(centros_x[i],centros_y[i]).transform("EPSG:4326", "EPSG:900913"),icon.clone()));
//markers.events.register('mousedown', marker, function(evt) { alert(estados[i]); OpenLayers.Event.stop(evt); });
}
map.setCenter (lonLat, zoom);
</script>
Podemos Observar el resultado, que contiene el mapa con la demarcación de las regiones, así como el icono que representa los centros de cada entidad, así como al final la leyenda de su representación:
Conexión de prueba para implementar en servidor
Se utiliza el servicio de uwsgi, en nuestro caso de prueba dada la facilidad que provee la herramienta django, se configura la conexión en el archivo wsgi.py o se mantiene la configuración que se genera al crear el proyecto por el framework. Debe estar la librería uwsgi , por medio las herramientas de instalación de Python en consola:
easy_install install uwsgi
Levantar el proceso por medio de la instrucción:
uwsgi --http <direccion ip servidor de prueba>:8000 --wsgi-file geodjango/wsgi.py
Con la utilización de este servicio se enlaza, por medio de socket, con el servidor web nginx.
Conclusión
El sistema permite representar las regiones seleccionadas según requiera el usuario con su respectiva gama de colores, que indiquen el resultado de la consulta en un mapa interactivo del país. Es esta primera fase se consultan la cantidad de unidades económicas presenten en cada región según la clasificación que ellas han determinado como actividad productiva, bajo la normativa del código único CIIU, y que hayan almacenado sus datos en el sistema Sigesic.
Como se puede destacar, el sistema esta diseñado como base para la representación de mapas de densidad, por lo cual se puede adaptar para su ampliación a consultas que arrojen resultados en pares: dato de estudio-cantidad.
| Observación | Responsable | Fecha |
| Continuación | Erwin Paredes | 25/04/2014 |
Attachments (7)
- gráficos6.png (760.0 KB) - added by eparedes 10 years ago.
- gráficos2.png (441.2 KB) - added by eparedes 10 years ago.
- gráficos3.png (707.0 KB) - added by eparedes 10 years ago.
- gráficos4.png (81.1 KB) - added by eparedes 10 years ago.
- gráficos5.png (178.0 KB) - added by eparedes 10 years ago.
- sectores_produccion.odt (249.1 KB) - added by eparedes 10 years ago.
- Caso_de_Uso_Sectores_Productivos.pdf (32.5 KB) - added by eparedes 10 years ago.
