Application: gvSIG desktop » gvSIG scripting

# -*- coding: utf-8 -*-

#

# File: gvsig.py

#

# Copyright (c) 2011 by Model Driven Development sl and Antonio Carrasco Valero

#

# GNU General Public License (GPL)

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

#

#

"""

This module contains classes and functions to manage gvSIG Project, 

gvSIG DocumentView, gvSIG TableDocument and Layers.

"""

__author__ = """Antonio Carrasco Valero

Model Driven Development sl and Antonio Carrasco Valero

<carrasco@modeldd.org>

Victor Acevedo Royer <vacevedor@gvsig.com>, <vacevedor@gmail.com>

"""

__docformat__ = 'plaintext'

from java.awt import Color

from java.lang import RuntimeException

from java.lang import Throwable

from java.util.prefs import Preferences

from org.gvsig.app import ApplicationLocator

from org.gvsig.app.project.documents.view import ViewDocument 

from org.gvsig.app.project.documents.table import TableDocument

from org.gvsig.fmap.crs import CRSFactory

from org.gvsig.fmap.mapcontext import MapContextLocator

from org.gvsig.fmap.mapcontext.layers import FLayers

from org.gvsig.fmap.dal import DALLocator, DataTypes

from org.gvsig.fmap.dal.feature import EditableFeature,  EditableFeatureType, FeatureQueryOrder

from org.gvsig.fmap.dal.feature.impl import DefaultEditableFeature

from org.gvsig.fmap.geom import Geometry

from org.gvsig.tools import ToolsLocator

import thread

import random

def runTask(name, function, *args):

  manager = ToolsLocator.getTaskStatusManager()

  status = manager.createDefaultSimpleTaskStatus(name)

  status.add()

  args = list(args)

  args.append(status)

  try:

    thread.start_new_thread(function, tuple(args))

    status.terminate()

  except Exception,e:

    status.abort()

    raise e

class WrapperToJava(object):

  """

  Create a wrapper that allows python object access to the Java object

  properties and methods

  """

  def __init__(self, javaobj):

    if javaobj == None:

      raise RuntimeException("Can't create "+ self.__class__.__name__)

    self._javaobj = javaobj

  def __call__(self):

    return self._javaobj

  def __getattr__(self,name):

    return getattr(self._javaobj,name)

class Project(WrapperToJava):

  """

  Represents a gvSIG project

  """

  def __init__(self, project):

    WrapperToJava.__init__(self, project)

  def getView(self, name=None):

    """

    Return active view, or view called 'name'  or None

      :param name: view name

      :type name: string

    """

    if name == None:

      try:

        activeDocument = self.getActiveDocument()

        if activeDocument == None:

            return None

        if isinstance(activeDocument, ViewDocument):

            return View(activeDocument)

      except Exception, ex:

        raise Exception("%s"%repr(ex))

    else:

      views = self.getViews()

      if len(views) >0:

        for view in views:

          if name == view.getName():

            return View(view)

    return None

  def getTable(self, name=None):

    """

    Return active Table Document, or Table Document called 'name'  or None

      :param name: Table Document name

      :type name: string

    """

    if name == None:

      try:

        activeDocument = self.getActiveDocument()

        if activeDocument == None:

            return None

        if isinstance(activeDocument, TableDocument):

            return Table(activeDocument)

      except Exception, ex:

        raise Exception("%s"%repr(ex))

    else:

      tables = self.getDocuments("project.document.table")

      if len(tables) >0:

        for table in tables:

          if name == table.getName():

            return Table(table)

    return None   

  def getProjectionCode(self):

    return self.getProjection().getFullCode()

class View(WrapperToJava):

  """

  Represents gvSIG view document.

  """

  def __init__(self,view):

    WrapperToJava.__init__(self,view)

  def getLayer(self, name=None):

    """

    Return one of the view layers documents. If name is None return view active 

    layer if the view has one, if name is not None return view called name else 

    return None.

      :param name: view name in Table Of Contents

      :type name: string

      :return: View

      :return: None

    """

    map = self.getMapContext();

    if name == None:

      activeLayers = map.getLayers().getActives()

      if len(activeLayers) != 1 :

        #raise RuntimeException("The view has not an active layer")

        return None

      for layer in activeLayers:

        if not isinstance(layer, FLayers):

          return Layer(layer)

      #raise RuntimeException("The view has not an active layer")

      return None

    ls = self.getLayers()

    for i in xrange(ls.getLayersCount()):

      l = ls.getLayer(i)

      if l.name == name:

        return Layer(l)

    return None

  def getMap(self):

    """

    Return view mapContext

    """

    return self.getMapContext();

  def addLayer(self, layer):

    if isinstance(layer, Layer):

      layer =layer()

    self.getMapContext().getLayers().addLayer(layer)

  def getLayers(self):

    """

    Return iterable view layers set

    """

    map = self.getMapContext()

    return Layers(map.getLayers())

  def getGraphicsLayer(self):

    """

    Return view graphics layer

    """

    return self.getMapContext().getGraphicsLayer()

  def getProjectionCode(self):

    return self.getProjection().getFullCode()

class Layers(WrapperToJava):

  """

  Iterable layers set

  """

  def __init__(self,layers):

    WrapperToJava.__init__(self, layers)

  def __len__(self):

    return self.getLayersCount()

  def __getitem__(self, index):

    return self.getLayer(index)

  def __iter__(self):

    return LayersIterator(self)

class LayersIterator(object):

  def __init__(self,layers):

    self.__layers = layers

    self.__index = -1

  def next(self):

    self.__index+=1

    if self.__index >= self.__layers.getLayersCount() :

      raise StopIteration()

    return Layer(self.__layers.getLayer(self.__index))    

class Store(WrapperToJava):

  """

  Represents gvsig store

  """

  def __init__(self,store):

    WrapperToJava.__init__(self, store)

    #self.data = None

    self.fset = None

  def features(self, expresion = None, sortBy="", asc=True):

    """

    Return layer features set (FeatureSet)

        :param expresion: filter to apply to the feature set to select

        determinates features that match with expression

        :type expresion: string

        :param sortBy: name of attribute to sort

        :type sortby: string

        :param: asc: order

        :type asc: boolean

        :return: FeatureSet

    """

    if expresion == None and sortBy =="":

      self.fset = self.getFeatureSet()         

    else:

      application = ApplicationLocator.getManager()

      datamanager =  application.getDataManager()

      query = self.createFeatureQuery()

      if sortBy != "":

        order = FeatureQueryOrder()

        order.add(sortBy, asc)

        query.setOrder(order)

      if expresion != None:

        query.setFilter(datamanager.createExpresion(expresion))

      #self.fset = data.getFeatureSet(query)    

      self.fset = self.getFeatureSet(query)

    return FeatureSet(self.fset)    

  def edit(self):

    """

    Set layer data store in edition mode

    """

    if not self.isEditing():

        self().edit() 

  def append(self, *valuesList, **values):

    """

    Create a new feature from given values and insert it in the feature set

      :param values: dictionary with name property value or list named params

      :type values: dict

    """

    try:

      if len(valuesList) ==1:

        values.update(valuesList[0])

      if not self.isEditing():

        self.edit() 

      f = self.createNewFeature()

      if f == None:

        raise RuntimeError("Failed to create a new Feature")

      for k,v in values.iteritems():

        f.set(k,v)

        self.insert(f)

    except Throwable, ex:

      raise RuntimeException("Can't append values %s to layer %s (%s)" % (

        repr(values), 

        self.getName(), 

        str(ex)

        )

      )

  def updateSchema(self, schema):

    try:

      self().update(schema._javaobj)

    except Throwable, ex:

      raise RuntimeException(repr(ex))

  def update(self, feature):

    """

    Update exist feature in the layer featureSet

      :param editableFeature: editableFeature

      :type editableFeature: Java editableFeature

    """

    if not isinstance(feature, EditableFeature):

      feature = feature._javaobj

    self.fset.update(feature)

  def getSchema(self):

    """

    Return layer schema definition

    """

    return Schema(self.getDefaultFeatureType())

  def commit(self):

    """

    Finish layer edition

    """

    try:

      self.finishEditing()          

    except Throwable, ex:

      self.abort()

      raise Throwable("Can't finish layer edition, cancelling changes. %s" % repr(ex))

  def abort(self):

    """

    Cancel layer edition

    """

    self.cancelEditing() 

    self.dispose()

  def getSelection(self):

    """

    Return layer feature selected set

    """

    return FeatureSet(self().getSelection())

class __DefaultTable__(WrapperToJava):

  def __init__(self,document, data):

    self.data = Store(data)

    WrapperToJava.__init__(self,document)

    self.selection = None

  def features(self, expresion = None, sortBy="", asc=True):

    """

    Return data features set

        :param expresion: filter to apply to the feature set to select

         determinates features that match with expression

        :type expresion: string

        :return: FeatureSet

    """

    return self.data.features(expresion, sortBy, asc)

  def edit(self):

    """

    Set data in edition mode

    """

    self.data.edit() 

  def append(self, *valuesList, **values):

    """

    Create a new feature from given values and insert it in the feature set

      :param values: dictionary with name property value or list named params

      :type values: dict

    """

    self.data.append(*valuesList, **values)

  def updateSchema(self, schema):

    """

    Update data schema definition with the given schema

    """

    self.data.updateSchema(schema)

  def update(self, feature):

    """

    Update exist feature in the featureSet

      :param editableFeature: editableFeature

      :type editableFeature: Java editableFeature

    """

    self.data.update(feature)

  def getSchema(self):

    """

    Return schema definition

    """

    return self.data.getSchema()

  def commit(self):

    """

    Finish edition

    """

    self.data.commit()

  def abort(self):

    """

    Cancel edition

    """

    self.data.abort()

  def getSelection(self):

    """

    Return features selected set

    """

    if self.selection == None:

      self.selection = self.data.getSelection()

    return self.selection

  def select(self, selection):

    """

    Insert features in the features selection set

    """

    if isinstance(selection,Feature) or isinstance(selection, FeatureSet):

      self.data.getSelection().select(selection._javaobj)

    else:

      self.data.getSelection().select(selection)

  def deselect(self, selection):

    """

    Remove features in the features selection set

    """

    if isinstance(selection,Feature) or isinstance(selection, FeatureSet):

      self.data.getSelection().deselect(selection._javaobj)

    else:

      self.data.getSelection().deselect(selection)

  def isSelected(feature):

    """

    Returns if feature is selected

    """

    if isinstance(feature, Feature):

      self.data.getSelection().deselect(feature._javaobj)

    else:

      self.data.getSelection().deselect(feature)

  def getProjectionCode(self):

    """

    Return layer projection code

    """

    return self.getProjection().getFullCode()

class Table(__DefaultTable__):

  """

  Represents gvsig layer document

  """

  def __init__(self,table):

    __DefaultTable__.__init__(self, table, table.getStore())

class Layer(__DefaultTable__):

  """

  Represents gvsig layer document

  """

  def __init__(self,layer):

    __DefaultTable__.__init__(self, layer, layer.getFeatureStore())

    #WrapperToJava.__init__(self,layer)

  def getTypeVectorLayer(self):

    return self().getTypeVectorLayer()

class FeatureSet(WrapperToJava):

  def __init__(self,featureSet):

    WrapperToJava.__init__(self,featureSet)

  def getCount(self):

    return self.getSize()

  def update(self, feature):

    """

    Update exist feature in the featureSet

      :param editableFeature: editableFeature

      :type editableFeature: Java editableFeature

    """

    if not isinstance(feature, EditableFeature) and not isinstance(feature, DefaultEditableFeature):

      feature = feature._javaobj

    self().update(feature)

  def __iter__(self):

    return  Iterator(self.fastIterator())

class Iterator(WrapperToJava):

  def __init__(self,iterator):

    WrapperToJava.__init__(self,iterator)

  def next(self):

    if not self.hasNext():

      raise StopIteration()

    return Feature(self().next())

class Feature(WrapperToJava):

  """

  Represents layer feature data

  """

  def __init__(self,feature):

    WrapperToJava.__init__(self,feature)

    self.featureNoEditable = None

  def geometry(self):

    """

    Return feature default geometry

    """

    return self.getDefaultGeometry()

  def getValues(self):

    """

    Return dictionary with name value attributes

    """

    descriptor = self.getType()

    items = dict()

    for attr in descriptor.getAttributeDescriptors():

      name = attr.getName()

      value = self.get(attr.getName())

      items[name] = value

    return items 

  def edit(self):

    """

    Return editable feature

    """

    if not isinstance(self._javaobj, EditableFeature):

      self.featureNoEditable = self._javaobj

      self._javaobj = self._javaobj.getEditable()

  def __getitem__(self,key):

    return self.get(key)

  def __getattr__(self,name):

    #

    #FIX console error when try to introspect feature object

    if name in ('__methods__'):

        return dict()

    elif name in ('__members__'):

        return self.getValues().keys()

    elif name == '__dict__':

        return self.getValues()      

    try:

      v = getattr(self._javaobj, name, None)

      if v == None:

        v = self().get(name)        

      return v

    except Throwable, ex:

      raise RuntimeException("Can't access to attribute %s of feature (%s)" % (name, str(ex)))    

class Schema(WrapperToJava):

  """

  Layer feature definition

  """

  def __init__(self, featureType):

    WrapperToJava.__init__(self,featureType)

    self.featureTypeNoEditable = None

  def append(self, name, type, size=None, default=None, precision=4):

    """

    Adds property to feature properties definition.

        :param name: Feature property name

        :type name: String

        :param type: Feature property type

        :type name: String

        :param size: Feature property size

        :type size: int

        :param default: Feature property default value

        :return: new atribute

    """

    if not isinstance(self._javaobj, EditableFeatureType):

      self.modify()

      #self.featureTypeNoEditable = self._javaobj

      #self._javaobj = self._javaobj.getEditable()

    if isinstance(type, str):

      try:

        application = ApplicationLocator.getManager()

        datamanager =  application.getDataManager()

        dataTypes = application.getDataTypesManager()

        type = dataTypes.getType(type) #dataType constant value from string

      except:

        raise RuntimeError(

            "Feature Property Data type (%s) is not valid.  name=%s, type=%s, size=%s, default=%s)" % (

                type, 

                name, 

                type, 

                size, 

                default

            )

        )

    if isinstance(type, int):

      try:

        type = dataTypes.get(type)

      except:

        raise RuntimeError(

            "Data type (%s) is not valid.  name=%s, type=%s, size=%s, default=%s)" % (

                type, 

                name, 

                type, 

                size, 

                default

            )

        )

    attribute = self.add(name, type.getType())

    if size != None: 

      attribute.setSize(size)

    if default != None:

      attribute.setDefaultValue(default)

    if precision != None and type.getType() in (DataTypes.DOUBLE, DataTypes.FLOAT):

      attribute.setPrecision(precision)

    if type.getType() == DataTypes.GEOMETRY and self.getDefaultGeometryAttributeName()==None:

      self.setDefaultGeometryAttributeName(name)

    return attribute

  def __getitem__(self, name):

    return self.getAttributeDescriptor(name)

  def get(self, name, default=None):

    """

    Return a feature attribute descriptor that contains information about 

    one of the attributes in a feature, such as its name, data type or 

    precision. 

      :param name: Attribute name

      :type name: string

      :param default: Value to return if no attribute name found. 

      :return: AttributeDescriptor

    """

    x = self.getAttributeDescriptor(name)

    if x == None:

      return default

    return x

  def getAttrNames(self):

    """

    Return list with definition schema atribute names 

    """

    names = list(attr.getName() for attr in self.getAttributeDescriptors())

    return names

  def getCopy(self):

    return Schema(self().getCopy())

  def modify(self):

    if not isinstance(self._javaobj, EditableFeatureType):

      self.featureTypeNoEditable = self._javaobj

      self._javaobj = self._javaobj.getEditable()

#=====================#

# Vectorial Functions #

#=====================#

def createSchema(schema = None):

  """

  Return empty layer definition

  """

  if schema != None:

    s = schema.getCopy()

    s.modify()

    return s

  application = ApplicationLocator.getManager()

  datamanager =  application.getDataManager()

  return Schema(datamanager.createFeatureType())

def createLayer(schema, servertype, layertype=None, **parameters):

  """ 

  Create a new layer and return it 

      :param schema: layer data definition

      :type schema: Schema

      :param servertype: 

      :type servertype: string

      :return: new layer

      :rtype: Layer

      :raise: RuntimeException

  """

  if layertype == None:

    layertype = servertype

    servertype = "FilesystemExplorer"

  if layertype == "Shape" :

    if schema.get("GEOMETRY",None) == None:

      raise RuntimeException("Shape need a field named GEOMETRY in the schema")

  #parameters["geometryType"] = getGeometryType(parameters["geometryType"])

  if parameters["geometryType"] == None:

    raise RuntimeException("Invalid geometry type for new layer")

  try:

    application = ApplicationLocator.getManager()

    datamanager =  application.getDataManager()

    mapcontextmanager = application.getMapContextManager()

    server_parameters = datamanager.createServerExplorerParameters(servertype)

    copyToDynObject(parameters, server_parameters)

    server = datamanager.openServerExplorer(servertype, server_parameters)

    store_parameters = server.getAddParameters(layertype)

    copyToDynObject(parameters, store_parameters)

    store_parameters.setDefaultFeatureType(schema())

    server.add(layertype, store_parameters, True)

    store = datamanager.openStore(layertype, store_parameters)

    layer = mapcontextmanager.createLayer(store.getName(), store)

    return Layer(layer)

  except Throwable, ex:

    raise RuntimeException("Can't create layer, "+ str(ex))

def loadShapeFile(shpFile, CRS="CRS:84"):

    """

    Add existing shape file to the view

    Return Layer

      :param shpFile: absolute file path

      :type: shpFile: string

      :param CRS: projection code

      :type CRS: string

      :return: the shape

      :type return: Layer

    """

    layer = loadLayer('Shape', shpFile=shpFile, CRS=CRS)

    currentView().addLayer(layer)

    #return currentView().getLayer(layer.getName())

    layer.setActive(True)

    return Layer(layer)

def loadLayer(layerType, **parameters):

    try:

        application = ApplicationLocator.getManager()

        datamanager =  application.getDataManager()

        mapcontextmanager = application.getMapContextManager()

        store_parameters = datamanager.createStoreParameters(layerType)

        copyToDynObject(parameters, store_parameters)

        store = datamanager.openStore(layerType, store_parameters)        

        layer = mapcontextmanager.createLayer(store.getName(), store)

    except Throwable, ex:

        raise RuntimeException("Can't load layer, "+ str(ex))  

    return layer

def createShape(definition, filename, geometryType, CRS="CRS:84"):

  """ 

  Create a new shape layer 

      :param definition: layer data definition

      :type definition: Schema

      :param filename: absolute path for shape files. 

      :type filename: string

      :param geometryType: geometry type for shape

      :type geometryType: string

      :return: new shape layer

      :rtype: Layer

  """

  return createLayer(

    definition, 

    "FilesystemExplorer", 

    "Shape", 

    shpFile=filename, 

    CRS=CRS,

    geometryType = geometryType

  )

def createTable(schema, servertype, tableType=None, **parameters):

  if tableType == None:

    tableType = servertype

    servertype = "FilesystemExplorer"

  try:

    application = ApplicationLocator.getManager()

    datamanager =  application.getDataManager()

    server_parameters = datamanager.createServerExplorerParameters(servertype)

    copyToDynObject(parameters, server_parameters)

    server = datamanager.openServerExplorer(servertype, server_parameters)

    store_parameters = server.getAddParameters(tableType)

    copyToDynObject(parameters, store_parameters)

    store_parameters.setDefaultFeatureType(schema())

    server.add(tableType, store_parameters, True)

    store = datamanager.openStore(tableType, store_parameters)

    return Table(store)

  except Throwable, ex:

    raise RuntimeException("Can't create table, "+ str(ex))

def createDBF(definition, DbfFile, CRS="wsg86"):

  """ 

  Create a new dbf document 

      :param definition: layer data definition

      :type definition: Schema

      :param DbfFile: absolute path for shape files. 

      :type DbfFile: string

      :return: new dbf

      :rtype: Table

  """

  return createTable(

    definition, 

    "FilesystemExplorer", 

    "DBF", 

    DbfFile=DbfFile, 

    CRS=CRS,

  )

#=====================#

# Documents Functions #

#=====================#  

def currentProject():

  """

  Return the current gvSIG proyect

    :return: Proyect

  """

  application = ApplicationLocator.getManager()

  project = application.getCurrentProject()

  return Project(project)

def currentDocument(documentClass = None):

  """

  Return the current active document if it's a DocumentTable or DocumentView2D

    :return: Active document, None

  """

  application = ApplicationLocator.getManager()

  if documentClass == None:

    doc = application.getActiveDocument()

  else:

    doc = application.getActiveDocument(documentClass)

  if isinstance(doc, TableDocument): #doc.getTypeName() == "project.document.table":

    return Table(doc)

  if isinstance(doc, ViewDocument): #doc.getTypeName() == "project.document.view2d": 

    return View(doc)  

  return None  

def currentTable():

  """

  Return the current active table document or None 

    :return: Table or None

  """  

  return currentDocument(TableDocument)

def currentView():

  """

  Return the current active view document or None 

    :return: View or None

  """ 

  return currentDocument(ViewDocument)

def currentLayer():

  """ 

  Return current view active layer

    :return: gvSIG active layer

  """

  try:

    return currentView().getLayer()

  except:

    return None

#=====================#

# Simbology Functions #

#=====================#  

def simplePointSymbol(color=None):

  """

  Return simple point symbol using parameter color. If no color use a ramdom color

    :param color: Java awt Color

    :return: gvSIG point symbol

  """

  if not isinstance(color, Color):

      color = getColor()

  return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.POINT, color)

def simpleLineSymbol(color=None):

  """

  Return simple line symbol using parameter color. If no color use a ramdom color

    :param color: Java awt Color

    :return: gvSIG line symbol

  """

  if not isinstance(color, Color):

      color = getColor()

  return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.CURVE, color)

def simplePolygonSymbol(color = None):

  """

  Return simple polygon symbol using parameter color. If no color use a ramdom color.

    :param color: Java awt Color

    :return: gvSIG poligon symbol

  """

  if not isinstance(color, Color):

      color = getColor()

  return MapContextLocator.getSymbolManager().createSymbol(Geometry.TYPES.SURFACE, color)

#=========================================#

# gvSIG Application Preferences Functions #

#=========================================#  

def getDataFolder():

  """

  Return gvSIG data folder. This folder is defined in application preferences

  If not defined return None

  """

  return Preferences.userRoot().node("gvsig.foldering").get('DataFolder', None)

def getProjectsFolder():

  """

  Return gvSIG projects folder. This folder is defined in application preferences.

  If not defined return None

  """

  return Preferences.userRoot().node("gvsig.foldering").get('ProjectsFolder', None)

def getColor():

  if MapContextLocator.getSymbolManager().isDefaultSymbolFillColorAleatory():

    color = Color(random.randint(0-255), 

              random.randint(0-255), 

              random.randint(0-255)

            )

  else:

    color = MapContextLocator.getSymbolManager().getSymbolPreferences().getDefaultSymbolFillColor()

  return color  

#================#

# OTHER          #

#================#

def getCRS(crs):

  """

  Return Projection from string code (i.e. CRS:84) if exist.

  """

  try:

    return CRSFactory.getCRS(crs)

  except:

    return None

def copyToDynObject(values, target):

  definition = target.getDynClass();

  fields = definition.getDynFields();

  for field in fields:

    name = field.getName()

    keys = values.keys()

    for k in keys:

      if k.lower() == name.lower():

        target.setDynValue(name, values[name])

        break

# ====================================

#

def main():

  layer = currentLayer()

  schema = createSchema()

  schema.append("ID", "String", 50)

  schema.append("GEOMETRY", "Geometry")

  output = createLayer(

      schema, 

      "FilesystemExplorer", 

      "Shape", 

      shpFile="/tmp/pp.shp", 

      CRS="EPSG:23030", 

      geometryType=POINT

  )

  for feature in layer.features():

    point = feature.geometry().centroid()

    output.append(ID=feature.ID, GEOMETRY=point)

  output.commit() 

  currentView().addLayer(output())