Application: gvSIG desktop » gvSIG scripting

execfile( script.getResource("../libs/import_utils.py").getAbsolutePath() )

import os

import os.path

from gvsig import *

from commonsdialog import *

from geom import *

from java.io import File

from java.lang import Thread

from java.awt import Dimension

from org.gvsig.tools import ToolsLocator

from org.gvsig.fmap.geom import GeometryLocator

from org.gvsig.fmap.geom import Geometry

from org.gvsig.fmap.dal import DALLocator

from org.gvsig.fmap.dal import DataTypes

import_from_module("imagegpsmetadata","ImageGPSMetadata")

import_from_module("..libs.relpath","relpath")

import_from_module("..libs.formpanel","ProgressBarWithTaskStatus,FormPanel")

class ProcessFolder(Thread):

  def __init__(self):

    self.__inputFolder = None

    self.__outputFile = None

    self.__addLayerToView = False

    self.__projection = "EPSG:4326"

    self.__onFinish = None

  def setOnFinish(self,onFinish):

    self.__onFinish = onFinish

  def setInputFoldername(self, inputFoldername):

    self.__inputFolder = File(inputFoldername)

  def setOutputFilename(self, outputFilename):

    self.__outputFile = File(outputFilename)

  def setAddLayerToView(self, add):

    self.__addLayerToView = add

  def createFeatureType(self):

    ft = DALLocator.getDataManager().createFeatureType()

    ft.add("id",DataTypes.INT)

    ft.add("text",DataTypes.STRING,100).setAllowNull(True)

    ft.add("fname",DataTypes.STRING,100).setAllowNull(True)

    ft.add("relpath",DataTypes.STRING,200).setAllowNull(True)

    ft.add("abspath",DataTypes.STRING,200).setAllowNull(True)

    ft.add("altitude",DataTypes.STRING,50).setAllowNull(True)

    ft.add("altitudere",DataTypes.STRING,50).setAllowNull(True)

    ft.add("datum",DataTypes.STRING,30).setAllowNull(True)

    ft.add("datestam",DataTypes.STRING,30).setAllowNull(True)

    ft.add("timestam",DataTypes.STRING,30).setAllowNull(True)

    attrg = ft.add("geometry",DataTypes.GEOMETRY)

    attrg.setGeometryType( 

      GeometryLocator.getGeometryManager().getGeometryType(

        Geometry.TYPES.POINT,

        Geometry.SUBTYPES.GEOM2D

      )

    )

    return ft

  def openShape(self): 

    dataManager = DALLocator.getDataManager()   

    openparams = dataManager.createStoreParameters("Shape")

    openparams.setDynValue("shpFile",self.__outputFile)

    openparams.setDynValue("crs",self.__projection)

    featurestore = dataManager.openStore("Shape",openparams)

    return featurestore

  def createShape(self):

    dataManager = DALLocator.getDataManager()

    serverparams = dataManager.createServerExplorerParameters("FilesystemExplorer")

    serverparams.setDynValue("root", self.__outputFile.getParent())

    server = dataManager.openServerExplorer("FilesystemExplorer", serverparams)

    addparams = server.getAddParameters("Shape")

    addparams.setDefaultFeatureType(self.createFeatureType())

    addparams.setDynValue("shpFile",self.__outputFile)

    addparams.setDynValue("crs",self.__projection)

    addparams.setDynValue("geometryType",Geometry.TYPES.POINT)

    server.add("Shape",addparams, False)

  def run(self):

    root = self.__outputFile.getParentFile()

    metadata_reader = ImageGPSMetadata()

    files = self.__inputFolder.list()

    if self.__outputFile.exists():

        self.__onFinish()

        return

    self.createShape()

    store = self.openShape()

    store.edit()

    n = 0

    for fname  in files:

      n += 1

      base, ext = os.path.splitext(fname)

      if not ext.lower() in (".jpg",".png",".jpeg"):

        continue

      f  = File(self.__inputFolder,fname)

      metadata_reader.load(f)

      feature = store.createNewFeature()

      feature.setDefaultGeometry(metadata_reader.getPoint())

      feature.set("id", n)

      feature.set("text", fname)

      feature.set("fname", fname)

      feature.set("relpath", relpath(f.getAbsolutePath(),root.getAbsolutePath()))

      feature.set("abspath", f.getAbsolutePath())

      feature.set("altitude", metadata_reader.getAltitude(""))

      feature.set("altitudere", metadata_reader.getAltitudeRef(""))

      feature.set("datum", metadata_reader.getDatum(""))

      feature.set("datestam", metadata_reader.getDate(""))

      feature.set("timestam", metadata_reader.getTime(""))

      store.insert(feature)

    store.finishEditing()

    if self.__addLayerToView:

      layer = MapContextLocator.getMapContextManager().createLayer(

        self.__outputFile.getName(),

        store

      )

      currentView().getMapContext().getLayers().addLayer(layer)

    self.__onFinish()

class Photo2shapePanel(FormPanel):

  def __init__(self):

    FormPanel.__init__(self,script.getResource("photo2shape3.xml"))

    self.getPanel().setPreferredSize(Dimension(500,140))

    self.txtInputFolder.setText(script.getResource("data/test-images").getAbsolutePath())

    self.txtOutputFile.setText(script.getResource("data/photos.shp").getAbsolutePath())

  def showWindow(self):

    FormPanel.showWindow(self, "Photo2shape")

  def btnInputFolder_click(self, *args):

    f = openFolderDialog("Select input folder")

    if f == None or len(f)<1:

      return

    self.txtInputFolder.setText(f[0].getAbsolutePath())

  def btnOutputFile_click(self, *args):

    f = saveFileDialog("Select output shape")

    if f == None or len(f)<1:

      return

    self.txtOutputFile.setText(f[0].getAbsolutePath())

  def btnClose_click(self, *args):

    self.hide()

  def btnMakeShape_click(self, *args):

    if self.chkRemoveShape.isSelected():

      try:

        f = os.path.splitext(self.txtOutputFile.getText())[0]

        os.remove(f+".shp")

        os.remove(f+".shx")

        os.remove(f+".dbf")

      except:

        pass

    if os.path.exists(self.txtOutputFile.getText()) :

      msgbox("output shapefile already exist")

      return

    self.btnMakeShape.setEnabled(False)

    self.btnClose.setEnabled(False)

    process = ProcessFolder()

    process.setInputFoldername(self.txtInputFolder.getText())

    process.setOutputFilename(self.txtOutputFile.getText())

    process.setAddLayerToView(self.chkInsertLayer.isSelected())

    process.setOnFinish(self.processFinished)

    process.start()

  def processFinished(self):

    self.btnMakeShape.setEnabled(True)

    self.btnClose.setEnabled(True)

def main(*args):

    win = Photo2shapePanel()

    win.showWindow()