unit.py

   1 # -*- encoding: utf-8 -*-
   2 #
   3 #
   4 # Copyright (C) 2002-2004 Jörg Lehmann <joergl@users.sourceforge.net>
   5 # Copyright (C) 2002-2004 André Wobst <wobsta@users.sourceforge.net>
   6 #
   7 # This file is part of PyX (http://pyx.sourceforge.net/).
   8 #
   9 # PyX is free software; you can redistribute it and/or modify
  10 # it under the terms of the GNU General Public License as published by
  11 # the Free Software Foundation; either version 2 of the License, or
  12 # (at your option) any later version.
  13 #
  14 # PyX is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with PyX; if not, write to the Free Software
  21 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  22
  23 import types
  24
  25 scale = { 't':1, 'u':1, 'v':1, 'w':1, 'x':1 }
  26
  27 _default_unit = "cm"
  28
  29 _m = {
  30       'm' :   1,
  31       'cm':   0.01,
  32       'mm':   0.001,
  33       'inch': 0.01*2.54,
  34       'pt':   0.01*2.54/72,
  35     }
  36
  37 def set(uscale=None, vscale=None, wscale=None, xscale=None, defaultunit=None):
  38     if uscale is not None:
  39         scale['u'] = uscale
  40     if vscale is not None:
  41         scale['v'] = vscale
  42     if wscale is not None:
  43         scale['w'] = wscale
  44     if xscale is not None:
  45         scale['x'] = xscale
  46     if defaultunit is not None:
  47         global _default_unit
  48         _default_unit = defaultunit
  49
  50
  51 def _convert_to(l, dest_unit="m"):
  52     if type(l) in (types.IntType, types.LongType, types.FloatType):
  53         return l * _m[_default_unit] * scale['u'] / _m[dest_unit]
  54     elif not isinstance(l, length):
  55         l = length(l)       # convert to length instance if necessary
  56
  57     return (l.t + l.u*scale['u'] + l.v*scale['v'] + l.w*scale['w'] + l.x*scale['x']) / _m[dest_unit]
  58
  59 def tom(l):
  60     return _convert_to(l, "m")
  61
  62 def tocm(l):
  63     return _convert_to(l, "cm")
  64
  65 def tomm(l):
  66     return _convert_to(l, "mm")
  67
  68 def toinch(l):
  69     return _convert_to(l, "inch")
  70
  71 def topt(l):
  72     return _convert_to(l, "pt")
  73
  74 ################################################################################
  75 # class for generic length
  76 ################################################################################
  77
  78 class length:
  79     """ PyX lengths
  80
  81     PyX lengths are composed of five components (t=true, u=user, v=visual,
  82     w=width, and x=TeX) which can be scaled separately (except for the true
  83     component, which is always unscaled). Lengths can be constructed in units
  84     of "pt", "mm", "cm", "m" and "inch". When no unit is given, a module
  85     default is used, which can be changed with the help of the module level function
  86     set().
  87     """
  88
  89     def __init__(self, f=0, type="u", unit=None):
  90         """ create a length instance of the given type with a length f
  91         in the given unit. If unit is not set, the currently set default unit is used.
  92         """
  93         self.t = self.u = self.v = self.w = self.x = 0
  94         l = float(f) * _m[unit or _default_unit]
  95         if type == "t":
  96             self.t = l
  97         elif type == "u":
  98             self.u = l
  99         elif type == "v":
 100             self.v = l
 101         elif type == "w":
 102             self.w = l
 103         elif type == "x":
 104             self.x = l
 105
 106     def __cmp__(self, other):
 107         # we try to convert self and other into meters and
 108         # if this fails, we give other a chance to do the comparison
 109         try:
 110             return cmp(tom(self), tom(other))
 111         except:
 112             # why does -cmp(other, self) not work?
 113             return -other.__cmp__(self)
 114
 115     def __mul__(self, factor):
 116         result = length()
 117         result.t = factor * self.t
 118         result.u = factor * self.u
 119         result.v = factor * self.v
 120         result.w = factor * self.w
 121         result.x = factor * self.x
 122         return result
 123
 124     __rmul__=__mul__
 125
 126     def __div__(self, divisor):
 127         if isinstance(divisor, length):
 128             return tom(self) / tom(divisor)
 129         result = length()
 130         result.t = self.t / divisor
 131         result.u = self.u / divisor
 132         result.v = self.v / divisor
 133         result.w = self.w / divisor
 134         result.x = self.x / divisor
 135         return result
 136
 137     __truediv__ = __div__
 138
 139     def __add__(self, other):
 140         # convert to length if necessary
 141         if not isinstance(other, length):
 142             # if other is not a length, we try to convert it into a length and
 143             # if this fails, we give other a chance to do the addition
 144             try:
 145                 other = length(other)
 146             except:
 147                 return other + self
 148         result = length()
 149         result.t = self.t + other.t
 150         result.u = self.u + other.u
 151         result.v = self.v + other.v
 152         result.w = self.w + other.w
 153         result.x = self.x + other.x
 154         return result
 155
 156     __radd__ = __add__
 157
 158     def __sub__(self, other):
 159         # convert to length if necessary
 160         if not isinstance(other, length):
 161             # if other is not a length, we try to convert it into a length and
 162             # if this fails, we give other a chance to do the subtraction
 163             try:
 164                 other = length(other)
 165             except:
 166                 return -other + self
 167         result = length()
 168         result.t = self.t - other.t
 169         result.u = self.u - other.u
 170         result.v = self.v - other.v
 171         result.w = self.w - other.w
 172         result.x = self.x - other.x
 173         return result
 174
 175     def __rsub__(self, other):
 176         # convert to length if necessary
 177         if not isinstance(other, length):
 178             other = length(other)
 179         result = length()
 180         result.t = other.t - self.t
 181         result.u = other.u - self.u
 182         result.v = other.v - self.v
 183         result.w = other.w - self.w
 184         result.x = other.x - self.x
 185         return result
 186
 187     def __neg__(self):
 188         result = length()
 189         result.t = -self.t
 190         result.u = -self.u
 191         result.v = -self.v
 192         result.w = -self.w
 193         result.x = -self.x
 194         return result
 195
 196     def __str__(self):
 197         return "(%(t)f t + %(u)f u + %(v)f v + %(w)f w + %(x)f x) m" % self.__dict__
 198
 199
 200 ################################################################################
 201 # predefined instances which can be used as length units
 202 ################################################################################
 203
 204 # user lengths and unqualified length which are also user length
 205 u_pt   = pt   = length(1, type="u", unit="pt")
 206 u_m    = m    = length(1, type="u", unit="m")
 207 u_mm   = mm   = length(1, type="u", unit="mm")
 208 u_cm   = cm   = length(1, type="u", unit="cm")
 209 u_inch = inch = length(1, type="u", unit="inch")
 210
 211 # true lengths
 212 t_pt   = length(1, type="t", unit="pt")
 213 t_m    = length(1, type="t", unit="m")
 214 t_mm   = length(1, type="t", unit="mm")
 215 t_cm   = length(1, type="t", unit="cm")
 216 t_inch = length(1, type="t", unit="inch")
 217
 218 # visual lengths
 219 v_pt   = length(1, type="v", unit="pt")
 220 v_m    = length(1, type="v", unit="m")
 221 v_mm   = length(1, type="v", unit="mm")
 222 v_cm   = length(1, type="v", unit="cm")
 223 v_inch = length(1, type="v", unit="inch")
 224
 225 # width lengths
 226 w_pt   = length(1, type="w", unit="pt")
 227 w_m    = length(1, type="w", unit="m")
 228 w_mm   = length(1, type="w", unit="mm")
 229 w_cm   = length(1, type="w", unit="cm")
 230 w_inch = length(1, type="w", unit="inch")
 231
 232 # TeX lengths
 233 x_pt   = length(1, type="x", unit="pt")
 234 x_m    = length(1, type="x", unit="m")
 235 x_mm   = length(1, type="x", unit="mm")
 236 x_cm   = length(1, type="x", unit="cm")
 237 x_inch = length(1, type="x", unit="inch")