Extensions/drawshape/drawshape.py

# Copyright (C) 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Extension to draw polygons

*** Warning: ***

This extension is very experimental and may corrupt your data. Use at
your own peril.
"""

__version__ = "$Revision$"
# $Source$
# $Id$


import os

from wxPython.wx import *

import shapelib
from Thuban.Model.data import SHAPETYPE_POLYGON
from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_STRING, \
     FIELDTYPE_DOUBLE
from Thuban.UI.command import registry, ToolCommand
import Thuban.UI.mainwindow
from Thuban.UI.viewport import Tool


def write_empty_row(table, row):
    """Write an empty record to the row

    The values in the record will be set to suitable default values
    depending on the type: 0 for numeric types and the empty string for
    strings.
    """
    values = {}
    for col in table.Columns():
        if col.type == FIELDTYPE_INT:
            value = 0
        elif col.type == FIELDTYPE_DOUBLE:
            value = 0.0
        elif col.type == FIELDTYPE_STRING:
            value = ""
        else:
            print "write_empty_row: Unhandled col.type", col.type
        values[col.name] = value
    table.write_record(row, values)


def write_shape(shapestore, points):
    """Addd the points as a new shape to the shapestore

    The points argument should be a list of the same structure as that
    returned by the shapelib bindings for a polygon. It is passed
    directly to the SHPObject constructor.
    """
    shapefile = shapelib.ShapeFile(shapestore.FileName(), "r+b")
    obj = shapelib.SHPObject(shapelib.SHPT_POLYGON, 1, points)
    newid = shapefile.write_object(-1, obj)
    write_empty_row(shapestore.Table(), newid)
    shapefile.close()
    shapestore._open_shapefile()


class ShapeDrawTool(Tool):

    def __init__(self, view):
        Tool.__init__(self, view)
        self.points = []

    def Name(self):
        return "ShapeDrawTool"

    def find_shapestore(self):
        """Return the shapestore into which to write and the projection

        If the currently selected layer is a layer with polygons return
        a tuple of the shapestore and the layer's projection.
        Otherwise return a tuple of Nones.
        """
        layer = self.view.SelectedLayer()
        if layer is not None and layer.HasShapes() \
               and layer.ShapeType() == SHAPETYPE_POLYGON:
            return layer.ShapeStore(), layer.GetProjection()
        return None, None

    def MouseDown(self, event):
        Tool.MouseDown(self, event)
        if event.RightDown():
            map_proj = self.view.Map().GetProjection()
            shapestore, proj = self.find_shapestore()
            if shapestore is not None and len(self.points) > 2:
                points = self.points[:]
                if map_proj is not None:
                    points = [tuple(map_proj.Inverse(*p)) for p in points]
                if proj is not None:
                    points = [tuple(proj.Forward(*p)) for p in points]
                points.append(points[0])
                write_shape(shapestore, [points])
                self.points = []
                self.view.full_redraw()
        else:
            if not self.points:
                self.points.append(self.view.win_to_proj(*self.current))

    def MouseUp(self, event):
        Tool.MouseUp(self, event)
        self.points.append(self.view.win_to_proj(*self.current))

    def draw(self, dc):
        points = [self.view.proj_to_win(*p) for p in self.points] \
                 + [self.current]
        if len(points) == 2:
            dc.DrawLines(points)
        else:
            dc.DrawPolygon(points)

    def DrawPermanent(self, dc):
        dc.SetPen(wxPen(wxColor(255, 128, 0), 2))
        dc.SetBrush(wxTRANSPARENT_BRUSH)
        dc.DrawPolygon([self.view.proj_to_win(*p) for p in self.points])


def shape_draw_tool(context):
    canvas = context.mainwindow.canvas
    canvas.SelectTool(ShapeDrawTool(canvas))

def check_shape_draw_tool(context):
    return context.mainwindow.canvas.CurrentTool() == "ShapeDrawTool"


iconfile = os.path.join(os.path.abspath(Thuban.__path__[0]),
                        "..", "Resources", "Bitmaps", "identify")
registry.Add(ToolCommand("shape_draw_tool", "Shape Draw Tool",
                         shape_draw_tool, icon = iconfile,
                         helptext = "Draw a shape",
                         checked = check_shape_draw_tool))

# Add the command to the toolbar
Thuban.UI.mainwindow.main_toolbar.InsertSeparator()
Thuban.UI.mainwindow.main_toolbar.InsertItem("shape_draw_tool")
1	# Copyright (C) 2003 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	#
5	# This program is free software under the GPL (>=v2)
6	# Read the file COPYING coming with the software for details.
7
8	"""Extension to draw polygons
9
10	* Warning: *
11
12	This extension is very experimental and may corrupt your data. Use at
13	your own peril.
14	"""
15
16	__version__ = "$Revision$"
17	# $Source$
18	# $Id$
19
20
21	import os
22
23	from wxPython.wx import *
24
25	import shapelib
26	from Thuban.Model.data import SHAPETYPE_POLYGON
27	from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_STRING, \
28	FIELDTYPE_DOUBLE
29	from Thuban.UI.command import registry, ToolCommand
30	import Thuban.UI.mainwindow
31	from Thuban.UI.viewport import Tool
32
33
34	def write_empty_row(table, row):
35	"""Write an empty record to the row
36
37	The values in the record will be set to suitable default values
38	depending on the type: 0 for numeric types and the empty string for
39	strings.
40	"""
41	values = {}
42	for col in table.Columns():
43	if col.type == FIELDTYPE_INT:
44	value = 0
45	elif col.type == FIELDTYPE_DOUBLE:
46	value = 0.0
47	elif col.type == FIELDTYPE_STRING:
48	value = ""
49	else:
50	print "write_empty_row: Unhandled col.type", col.type
51	values[col.name] = value
52	table.write_record(row, values)
53
54
55	def write_shape(shapestore, points):
56	"""Addd the points as a new shape to the shapestore
57
58	The points argument should be a list of the same structure as that
59	returned by the shapelib bindings for a polygon. It is passed
60	directly to the SHPObject constructor.
61	"""
62	shapefile = shapelib.ShapeFile(shapestore.FileName(), "r+b")
63	obj = shapelib.SHPObject(shapelib.SHPT_POLYGON, 1, points)
64	newid = shapefile.write_object(-1, obj)
65	write_empty_row(shapestore.Table(), newid)
66	shapefile.close()
67	shapestore._open_shapefile()
68
69
70	class ShapeDrawTool(Tool):
71
72	def __init__(self, view):
73	Tool.__init__(self, view)
74	self.points = []
75
76	def Name(self):
77	return "ShapeDrawTool"
78
79	def find_shapestore(self):
80	"""Return the shapestore into which to write and the projection
81
82	If the currently selected layer is a layer with polygons return
83	a tuple of the shapestore and the layer's projection.
84	Otherwise return a tuple of Nones.
85	"""
86	layer = self.view.SelectedLayer()
87	if layer is not None and layer.HasShapes() \
88	and layer.ShapeType() == SHAPETYPE_POLYGON:
89	return layer.ShapeStore(), layer.GetProjection()
90	return None, None
91
92	def MouseDown(self, event):
93	Tool.MouseDown(self, event)
94	if event.RightDown():
95	map_proj = self.view.Map().GetProjection()
96	shapestore, proj = self.find_shapestore()
97	if shapestore is not None and len(self.points) > 2:
98	points = self.points[:]
99	if map_proj is not None:
100	points = [tuple(map_proj.Inverse(*p)) for p in points]
101	if proj is not None:
102	points = [tuple(proj.Forward(*p)) for p in points]
103	points.append(points[0])
104	write_shape(shapestore, [points])
105	self.points = []
106	self.view.full_redraw()
107	else:
108	if not self.points:
109	self.points.append(self.view.win_to_proj(*self.current))
110
111	def MouseUp(self, event):
112	Tool.MouseUp(self, event)
113	self.points.append(self.view.win_to_proj(*self.current))
114
115	def draw(self, dc):
116	points = [self.view.proj_to_win(*p) for p in self.points] \
117	+ [self.current]
118	if len(points) == 2:
119	dc.DrawLines(points)
120	else:
121	dc.DrawPolygon(points)
122
123	def DrawPermanent(self, dc):
124	dc.SetPen(wxPen(wxColor(255, 128, 0), 2))
125	dc.SetBrush(wxTRANSPARENT_BRUSH)
126	dc.DrawPolygon([self.view.proj_to_win(*p) for p in self.points])
127
128
129	def shape_draw_tool(context):
130	canvas = context.mainwindow.canvas
131	canvas.SelectTool(ShapeDrawTool(canvas))
132
133	def check_shape_draw_tool(context):
134	return context.mainwindow.canvas.CurrentTool() == "ShapeDrawTool"
135
136
137	iconfile = os.path.join(os.path.abspath(Thuban.__path__[0]),
138	"..", "Resources", "Bitmaps", "identify")
139	registry.Add(ToolCommand("shape_draw_tool", "Shape Draw Tool",
140	shape_draw_tool, icon = iconfile,
141	helptext = "Draw a shape",
142	checked = check_shape_draw_tool))
143
144	# Add the command to the toolbar
145	Thuban.UI.mainwindow.main_toolbar.InsertSeparator()
146	Thuban.UI.mainwindow.main_toolbar.InsertItem("shape_draw_tool")
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision