#
# Copyright (c) 2004, 2005 Art Haas
#
# This file is part of PythonCAD.
#
# PythonCAD 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.
#
# PythonCAD 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 PythonCAD; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
import sys
from PythonCAD.Generic.image import Image
from PythonCAD.Generic.util import make_region
from PythonCAD.Generic.graphicobject import GraphicObject
from PythonCAD.Generic.color import Color
from PythonCAD.Generic.point import Point
from PythonCAD.Generic.segment import Segment
from PythonCAD.Generic.circle import Circle
from PythonCAD.Generic.arc import Arc
#from PythonCAD.Generic.ellipse import Ellipse
from PythonCAD.Generic.polyline import Polyline
from PythonCAD.Generic.leader import Leader
from PythonCAD.Generic.segjoint import Chamfer, Fillet
from PythonCAD.Generic.conobject import ConstructionObject
from PythonCAD.Generic.text import TextStyle, TextBlock
from PythonCAD.Generic import dimension
from PythonCAD.Generic import util
class Plot(object):
__white = Color(255, 255, 255)
def __init__(self, image):
if not isinstance(image, Image):
raise TypeError, "Invalid image argument: " + `image`
self.__image = image
self.__bounds = None
self.__landscape = False
self.__invert = False
self.__color = False
self.__units = None
self.__data = {}
def __contains__(self, objtype):
if not isinstance(objtype, str):
raise TypeError, "Invalid object type string: " + `objtype`
return objtype in self.__data
def finish(self):
self.__image = self.__bounds = self.__units = None
self.__data.clear()
def setBounds(self, xmin, ymin, xmax, ymax):
self.__bounds = make_region(xmin, ymin, xmax, ymax)
def getBounds(self):
return self.__bounds
def setLandscapeMode(self, flag):
util.test_boolean(flag)
self.__landscape = flag
def getLandscapeMode(self):
return self.__landscape
def invertWhite(self, flag):
util.test_boolean(flag)
self.__invert = flag
def setColorMode(self, flag):
util.test_boolean(flag)
self.__color = flag
def setUnits(self):
self.__units = self.__image.getUnits()
def getUnits(self):
if self.__units is None:
self.setUnits()
return self.__units
def _getGraphicValues(self, obj):
if not isinstance(obj, GraphicObject):
raise TypeError, "Invalid GraphicObject: " + `obj`
_col = None
if self.__color:
_c = obj.getColor()
if self.__invert and _c == Plot.__white:
_col = (0, 0, 0) # black
else:
_col = _c.getColors() # r, g, b
_lt = obj.getLinetype().getList()
_t = obj.getThickness()
return _col, _lt, _t
def getPlotData(self):
if self.__bounds is None:
raise ValueError, "Plot boundary not defined."
if self.__units is None:
self.setUnits()
_xmin, _ymin, _xmax, _ymax = self.__bounds
_image = self.__image
_layers = [_image.getTopLayer()]
while len(_layers):
_layer = _layers.pop()
if _layer.isVisible():
for _obj in _layer.objsInRegion(_xmin, _ymin, _xmax, _ymax):
if isinstance(_obj, ConstructionObject):
continue # do not plot these
if not _obj.isVisible():
continue
if isinstance(_obj, Point):
continue # print points as dots?
elif isinstance(_obj, Segment):
_p1, _p2 = _obj.getEndpoints()
_x1, _y1 = _p1.getCoords()
_x2, _y2 = _p2.getCoords()
_col, _lt, _t = self._getGraphicValues(_obj)
_data = self.__data.setdefault('segments', [])
_data.append((_x1, _y1, _x2, _y2, _col, _lt, _t))
elif isinstance(_obj, Circle):
_x, _y = _obj.getCenter().getCoords()
print "x: %g; y: %g" % (_x, _y)
_r = _obj.getRadius()
print "r: %g" % _r
_col, _lt, _t = self._getGraphicValues(_obj)
_data = self.__data.setdefault('circles', [])
_data.append((_x, _y, _r, _col, _lt, _t))
elif isinstance(_obj, Arc):
_x, _y = _obj.getCenter().getCoords()
_r = _obj.getRadius()
_sa = _obj.getStartAngle()
_ea = _obj.getEndAngle()
_col, _lt, _t = self._getGraphicValues(_obj)
_data = self.__data.setdefault('arcs', [])
_data.append((_x, _y, _r, _sa, _ea, _col, _lt, _t))
elif isinstance(_obj, Leader):
_p1, _p2, _p3 = _obj.getPoints()
_x1, _y1 = _p1.getCoords()
_x2, _y2 = _p2.getCoords()
_x3, _y3 = _p3.getCoords()
_ax1 = _ax2 = _x3
_ay1 = _ay2 = _y3
if _obj.getArrowSize() > 1e-10:
_pts = _obj.getArrowPoints()
_ax1 = _pts[0]
_ay1 = _pts[1]
_ax2 = _pts[2]
_ay2 = _pts[3]
_col, _lt, _t = self._getGraphicValues(_obj)
_data = self.__data.setdefault('leaders', [])
_data.append((_x1, _y1, _x2, _y2, _x3, _y3,
_ax1, _ay1, _ax2, _ay2,
_col, _lt, _t))
elif isinstance(_obj, Polyline):
_pts = []
for _pt in _obj.getPoints():
_pts.append(_pt.getCoords())
_col, _lt, _t = self._getGraphicValues(_obj)
_data = self.__data.setdefault('polylines', [])
_data.append((_pts, _col, _lt, _t))
elif isinstance(_obj, Chamfer):
_p1, _p2 = _obj.getMovingPoints()
_col, _lt, _t = self._getGraphicValues(_obj)
_data = self.__data.setdefault('chamfers', [])
_data.append((_p1.x, _p1.y, _p2.x, _p2.y,
_col, _lt, _t))
elif isinstance(_obj, Fillet):
_x, _y = _obj.getCenter()
_r = _obj.getRadius()
_sa, _ea = _obj.getAngles()
_col, _lt, _t = self._getGraphicValues(_obj)
_data = self.__data.setdefault('fillets', [])
_data.append((_x, _y, _r, _sa, _ea, _col, _lt, _t))
elif isinstance(_obj, dimension.Dimension):
self._saveDimensionData(_obj)
elif isinstance(_obj, TextBlock):
_tbdata = self._getTextBlockData(_obj)
if _tbdata is not None:
_data = self.__data.setdefault('textblocks', [])
_data.append(_tbdata)
else: # fixme
pass
_layers.extend(_layer.getSublayers())
def _getTextBlockData(self, tblock):
_bounds = tblock.getBounds()
if _bounds is None: # raise Exception?
return
_tbdata = {}
_tbdata['bounds'] = _bounds
_tbdata['location'] = tblock.getLocation()
_family = tblock.getFamily()
if _family.find(' ') != -1:
_family = _family.replace(' ', '-')
_val = tblock.getWeight()
_weight = None
if _val != TextStyle.WEIGHT_NORMAL:
if _val == TextStyle.WEIGHT_LIGHT:
_weight = 'light'
elif _val == TextStyle.WEIGHT_BOLD:
_weight = 'bold'
elif _val == TextStyle.WEIGHT_HEAVY:
_weight = 'heavy'
else:
raise ValueError, "Unexpected font weight: %d" % _val
_val = tblock.getStyle()
_style = None
if _val != TextStyle.FONT_NORMAL:
if _val == TextStyle.FONT_OBLIQUE:
_style = 'oblique'
elif _val == TextStyle.FONT_ITALIC:
_style = 'italic'
else:
raise ValueError, "Unexpected font style: %d" % _val
if _weight is None and _style is None:
_font = _family
else:
if _weight is None:
_font = "%s-%s" % (_family, _style)
elif _style is None:
_font = "%s-%s" % (_family, _weight)
else:
_font = "%s-%s%s" % (_family, _style, _weight)
_tbdata['font'] = _font
_col = None
if self.__color:
_c = tblock.getColor()
if self.__invert and _c == Plot.__white:
_col = (0, 0, 0) # black
else:
_col = _c.getColors() # r, g, b
_tbdata['color'] = _col
_val = tblock.getAlignment()
if _val == TextStyle.ALIGN_LEFT:
_align = 'left'
elif _val == TextStyle.ALIGN_CENTER:
_align = 'center'
elif _val == TextStyle.ALIGN_RIGHT:
_align = 'right'
else:
raise ValueError, "Unexpected alignment: %d" % _val
_tbdata['align'] = _align
_tbdata['size'] = tblock.getSize()
_tbdata['angle'] = tblock.getAngle()
_tbdata['text'] = tblock.getText().splitlines()
# return (_x, _y, _bounds, _font, _col, _align, _size, _angle, _text)
return _tbdata
def _saveDimensionData(self, dim):
if isinstance(dim, dimension.LinearDimension):
self._saveLDimData(dim)
elif isinstance(dim, dimension.RadialDimension):
self._saveRDimData(dim)
elif isinstance(dim, dimension.AngularDimension):
self._saveADimData(dim)
else:
raise TypeError, "Unexpected dimension type: " + `dim`
def _getDimGraphicData(self, dim):
_col = None
if self.__color:
_c = dim.getColor()
if self.__invert and _c == Plot.__white:
_col = (0, 0, 0) # black
else:
_col = _c.getColors() # r, g, b
return _col
def _getDimMarkers(self, dim):
_data = {}
_etype = dim.getEndpointType()
if isinstance(dim, dimension.AngularDimension):
_crossbar = dim.getDimCrossarc()
else:
_crossbar = dim.getDimCrossbar()
_mp1, _mp2 = _crossbar.getCrossbarPoints()
if (_etype == dimension.Dimension.DIM_ENDPT_ARROW or
_etype == dimension.Dimension.DIM_ENDPT_FILLED_ARROW or
_etype == dimension.Dimension.DIM_ENDPT_SLASH):
_epts = _crossbar.getMarkerPoints()
_data['p1'] = _epts[0]
_data['p2'] = _epts[1]
_data['p3'] = _epts[2]
_data['p4'] = _epts[3]
_data['v1'] = _mp1
_data['v2'] = _mp2
if _etype == dimension.Dimension.DIM_ENDPT_ARROW:
_data['type'] = 'arrow'
elif _etype == dimension.Dimension.DIM_ENDPT_FILLED_ARROW:
_data['type'] = 'filled_arrow'
elif _etype == dimension.Dimension.DIM_ENDPT_SLASH:
_data['type'] = 'slash'
elif _etype == dimension.Dimension.DIM_ENDPT_CIRCLE:
_data['type'] = 'circle'
_data['radius'] = dim.getEndpointSize()
_data['c1'] = _mp1
_data['c2'] = _mp2
elif _etype == dimension.Dimension.DIM_ENDPT_NONE:
_data['type'] = None
else:
raise ValueError, "Unexpected endpoint type: %d" % _etype
return _data
def _saveLDimData(self, dim):
_dimdata = {}
_bar1, _bar2 = dim.getDimBars()
_ep1, _ep2 = _bar1.getEndpoints()
_dimdata['ep1'] = _ep1
_dimdata['ep2'] = _ep2
_ep3, _ep4 = _bar2.getEndpoints()
_dimdata['ep3'] = _ep3
_dimdata['ep4'] = _ep4
_ep5, _ep6 = dim.getDimCrossbar().getEndpoints()
_dimdata['ep5'] = _ep5
_dimdata['ep6'] = _ep6
_eptype = dim.getEndpointType()
_dimdata['eptype'] = _eptype
_dimdata['color'] = self._getDimGraphicData(dim)
_dimdata['thickness'] = dim.getThickness()
_ds1, _ds2 = dim.getDimstrings()
_dimdata['ds1'] = self._getTextBlockData(_ds1)
if dim.getDualDimMode():
_dimdata['ds2'] = self._getTextBlockData(_ds2)
_dimdata['markers'] = self._getDimMarkers(dim)
_data = self.__data.setdefault('ldims', [])
_data.append(_dimdata)
def _saveRDimData(self, dim):
_dimdata = {}
_ep1, _ep2 = dim.getDimCrossbar().getEndpoints()
_dimdata['ep1'] = _ep1
_dimdata['ep2'] = _ep2
_dimdata['color'] = self._getDimGraphicData(dim)
_dimdata['thickness'] = dim.getThickness()
_ds1, _ds2 = dim.getDimstrings()
_dimdata['dia_mode'] = dim.getDiaMode()
_dimdata['ds1'] = self._getTextBlockData(_ds1)
if dim.getDualDimMode():
_dimdata['ds2'] = self._getTextBlockData(_ds2)
_mdata = self._getDimMarkers(dim)
if not dim.getDiaMode() and _mdata['type'] is not None:
_mdata['rdim'] = True
_dimdata['markers'] = _mdata
_data = self.__data.setdefault('rdims', [])
_data.append(_dimdata)
def _saveADimData(self, dim):
_dimdata = {}
_bar1, _bar2 = dim.getDimBars()
_ep1, _ep2 = _bar1.getEndpoints()
_dimdata['ep1'] = _ep1
_dimdata['ep2'] = _ep2
_ep3, _ep4 = _bar2.getEndpoints()
_dimdata['ep3'] = _ep3
_dimdata['ep4'] = _ep4
_dimdata['vp'] = dim.getVertexPoint().getCoords()
_crossarc = dim.getDimCrossarc()
_r = _crossarc.getRadius()
_dimdata['r'] = _r
_sa = _crossarc.getStartAngle()
_dimdata['sa'] = _sa
_ea = _crossarc.getEndAngle()
_dimdata['ea'] = _ea
_dimdata['color'] = self._getDimGraphicData(dim)
_dimdata['thickness'] = dim.getThickness()
_ds1, _ds2 = dim.getDimstrings()
_dimdata['ds1'] = self._getTextBlockData(_ds1)
if dim.getDualDimMode():
_dimdata['ds2'] = self._getTextBlockData(_ds2)
_dimdata['markers'] = self._getDimMarkers(dim)
_data = self.__data.setdefault('adims', [])
_data.append(_dimdata)
def getPlotEntities(self, entity):
return self.__data[entity]
