Creacion de contenedores de datos vectoriales
Los contenedores de datos vectoriales desde la extensión de
scripting de gvSIG son 2, el objeto Table, y el objeto Layer. Ambos
objetos contienen registros y la principal diferencia entre ellos
respecto los datos que contienen es que un registro de una capa
contiene un campo 'GEOMETRY'.
Hemos visto como acceder a los objetos Table y Layer tanto a través
de las funciones currentTable() y currentLayer() y a través del
objeto Project, mediante el método getTable, y del objeto Vista
mediante el método getLayer(), respectivamente. Ahora veremos cómo
crear estos objetos.
El esquema ( Schema ).
A la hora de crear un contenedor de datos, lo primero que deberemos
hacer es crear un esquema que represente esos datos. Este esquema
como mínimo deberá tener un campo de tipo Geometry si vamos a crear
una capa (Layer).
Función createSchema()
Existe una función que nos permite crar una definición de datos de
forma rápida, ya sea una copia de una definición existente o una
definición completamente nueva a la que iremos añadiendo las
propiedades que deseemos.
La sintaxis de la función es:
createSchema([schema])
- createSchema(schema): Devuelve una nueva instancia de un
Schema.
- schema, Schema (opcional): Si se invoca pasándole
como parámetro un objeto Schema, tratará de realizar una copia
del mismo y la devolverá en modo edición, si no puede realizar
la copia devolverá un Schema nuevo vacío en modo edición.
Añadir campos a una definición de datos. El método append
El método append de una definición de datos nos permite añadir un
atributo nuevo a la definición de los datos y definir sus
propiedades. Si la definición de datos no está en modo edición al
invocar este método se activará.
schema.append(name, type, size, default, precision)
- name, string: Nombre de la propiedad
- type, string: Tipo de dato que va a contener. Los valores
admitidos más usuales son:
- "BOOLEAN"
- "DOUBLE"
- "FLOAT"
- "INTEGER"
- "LONG"
- "STRING"
- "GEOMETRY"
Existen más tipos de datos que pueden usarse y puedes
consultarlos en la documentación de los DataTypes
- size, int (opcional): Tamaño de la propiedad. Determina el
tamaño máximo de los datos de tipo string. También se utiliza en
la representación del dato.
El tamaño por defecto del campo que se va a crear
es 1 por lo que es recomendable indicar el tamaño del
campo.
- default, object (opcional): Valor por defecto de la propiedad
si no se indica ningún otro.
El valor por defecto en tipos numéricos es el 0
(cero), y en cadenas es “” (cadena vacía)
- precision, int (opcional): Establece el número de decimales
del tipo de datos, si este es numérico y admite decimales.
El valor por defecto del atributo precision es 4,
por lo que si necesitamos una precisión mayor será
necesario indicarlo.
Ejemplos
Por ejemplo, queremos crear una definición de datos que usaremos
luego en una tabla dxf y solo queremos que tenga un campo llamado
"ID" de tipo LONG
schema = createSchema()
schema.append("ID", "LONG", 15)
También podemos queremos obtener una copia de la estructura de datos
de la capa activa y añadirle una propiedad más, por ejemplo de tipo
string, con un tamaño de 25 carácteres y con valor por defecto "Sin
modificar".
schema = createSchema(currentLayer.getSchema())
schema.append("Campo", "STRING", size=25, default="Sin modificar")
El siguiente código crea un Schema con 3 campos, "ID", "Nombre",
"Geometry"
from gvsig import *
def main():
schema = createSchema()
schema.append("ID", "Integer", 5)
schema.append("Nombre", "String", 50)
schema.append("GEOMETRY", "Geometry")
Crear una capa de tipo shape
Para crear una capa de tipo shape, es necesario tener en cuenta que
el schema tiene que tener obligatoriamente un campo llamado
"GEOMETRY" de tipo "Geometry". En caso de que este campo no esté
definido en el Schema, se producirá un error.
Puede crearse un shape mediante la función createShape , que
devuelve la capa recien creada y cuya sintaxis es:
createShape(schema, filename [, CRS] [,geometryType])
- schema, Schema: Definición de los datos.
- filename, string: Ruta absoluta donde debe guardarse el nuevo
archivo shape
- CRS, string (opcional): Código del sistema de referencia. Si
no se indica uno por defecto se establecerá WGS 84.
- geometryType, GeometryType (opcional): Tipo de geometría del
shape. Si no se indica el tipo de geometría el valor por defecto
es POINT. Los otros valores admitidos son:
- POINT
- LINE
- POLYGON
- MULTIPOINT
- MULTILINE
- MULTIPOLYGON
Siguiendo con nuestro ejemplo, una vez que tenemos nuestro schema
crearemos un shape en la carpeta "/tmp/pruebaShape.shp" (puedes
cambiar la ruta y usar cualquier otra en la que tengas permisos de
escritura), usando como CRS "EPSG:23030".
Nota: El siguiente código crea únicamente una capa sin features
import tempfile
import os.path
from gvsig import *
from geom import *
def main():
ruta = os.path.join(tempfile.gettempdir(),"pruebaShape.shp")
schema = createSchema()
schema.append("ID", "Integer", 5)
schema.append("Nombre", "String", 50)
schema.append("GEOMETRY", "Geometry")
newShape = createShape(
schema,
shpFile=ruta,
CRS="EPSG:23030",
geometryType=POINT
)
Creación de una tabla de tipo DBF
Al igual que para crear una capa (shape), lo primero que debemos
hacer para crear una tabla (DBF), es establecer su estructura de
datos, mediante un objeto Schema.
La diferencia más notable a la hora de crear una tabla es que no es
necesario que haya definido un campo "GEOMETRY" en el Schema, por lo
que el código para crear un dbf igual que en el ejemplo anterior
sería:
import tempfile
import os.path
from gvsig import *
def main():
ruta = os.path.join(tempfile.gettempdir(), "pruebaDBF.dbf")
schema = createSchema()
schema.append("ID", "Integer", 5)
schema.append("Nombre", "String", 50)
newTable = createTable(
schema,
shpFile=ruta,
CRS="EPSG:23030",
)
Supongamos que tenemos una capa cargada en la Vista y queremos crear
una tabla, cuyos campos serían "ID" que será un contador, otro campo
"IDFeature" que será el valor del campo "ID" de la capa de entrada,
y un último campo "COMENTARIOS" con un tamaño de 200 caracteres.
import tempfile
import os.path
from gvsig import *
def main():
#Establecemos donde vamos a guardar el dbf
ruta = os.path.join(tempfile.gettempdir(),"ejemploDBF.dbf")
#Obtenemos la capa de entrada
layer = currentLayer()
#Obtenemos el codigo de la proyeccion de la capa
crs = layer.getProjectionCode()
#Obtenemos la definición de datos de la capa de entrada
layerSchema = layer.getSchema()
#Obtenemos el atributo 'ID'
attr = layerSchema.get("ID")
#Obtenemos el tipo de dato y el tamaño del atributo
tipoDeDato = attr.getDataTypeName()
size = attr.getSize()
#Creamos la definición de datos
schema = createSchema()
schema.append("ID", "Long", 10)
schema.append("IDFeature", tipoDeDato, size)
schema.append("COMENTARIOS", "String", 200)
#Creamos la tabla
newTable = createTable(
schema,
shpFileruta,
CRS=crs,
)
#Obtenemos los fenómenos de la capa de entrada
features = layer.features()
#Inicializamos las variable
values = dict()
for index, feature in enumerate(features):
# Obtenemos los datos de los nuevos registros
values["ID"] = index
values["IDFeature"] = feature.get("ID")
values["COMENTARIOS"] =""
#Añadimos los registros a la tabla nueva
newTable.append(values)
#Terminamos la edición de la tabla guardando los cambios
newTable.commit()