Coverage for /usr/local/lib/python3.11/dist-packages/pyrocko/plot/smartplot.py: 74%

1# http://pyrocko.org - GPLv3 

2# 

3# The Pyrocko Developers, 21st Century 

4# ---|P------/S----------~Lg---------- 

5 

6''' 

7Matplotlib plotting with some fancy extras. 

8''' 

9 

10from collections import defaultdict 

11import math 

12import logging 

13 

14import numpy as num 

15import matplotlib 

16from matplotlib.axes import Axes 

17# from matplotlib.ticker import MultipleLocator 

18from matplotlib import cm, colors, colorbar, figure 

19 

20from pyrocko.guts import Tuple, Float, Object 

21from pyrocko import plot 

22 

23import scipy.optimize 

24 

25logger = logging.getLogger('pyrocko.plot.smartplot') 

26 

27guts_prefix = 'pf' 

28 

29inch = 2.54 

30 

31 

32def get_callbacks(obj): 

33 try: 

34 return obj.callbacks 

35 except AttributeError: 

36 return obj._callbacks 

37 

38 

39class SmartplotAxes(Axes): 

40 

41 if matplotlib.__version__.split('.') < '3.6'.split('.'): 

42 # Subclassing cla is deprecated on newer mpl but need this fallback for 

43 # older versions. Code is duplicated because mpl behaviour depends 

44 # on the existence of cla in the subclass... 

45 def cla(self): 

46 if hasattr(self, 'callbacks'): 

47 callbacks = self.callbacks 

48 Axes.cla(self) 

49 self.callbacks = callbacks 

50 else: 

51 Axes.cla(self) 

52 

53 else: 

54 def clear(self): 

55 if hasattr(self, 'callbacks'): 

56 callbacks = self.callbacks 

57 Axes.clear(self) 

58 self.callbacks = callbacks 

59 elif hasattr(self, '_callbacks'): 

60 callbacks = self._callbacks 

61 Axes.clear(self) 

62 self._callbacks = callbacks 

63 else: 

64 Axes.clear(self) 

65 

66 

67class SmartplotFigure(figure.Figure): 

68 

69 def set_smartplot(self, plot): 

70 self._smartplot = plot 

71 

72 def draw(self, *args, **kwargs): 

73 if hasattr(self, '_smartplot'): 

74 try: 

75 self._smartplot._update_layout() 

76 except NotEnoughSpace: 

77 logger.error('Figure is too small to show the plot.') 

78 return 

79 

80 return figure.Figure.draw(self, *args, **kwargs) 

81 

82 

83def limits(points): 

84 lims = num.zeros((3, 2)) 

85 if points.size != 0: 

86 lims[:, 0] = num.min(points, axis=0) 

87 lims[:, 1] = num.max(points, axis=0) 

88 

89 return lims 

90 

91 

92def wcenter(rect): 

93 return rect[0] + rect[2]*0.5 

94 

95 

96def hcenter(rect): 

97 return rect[1] + rect[3]*0.5 

98 

99 

100def window_min(n, w, ml, mu, s, x): 

101 return ml + x/float(n) * (w - (ml + mu + (n-1)*s)) + math.floor(x) * s 

102 

103 

104def window_max(n, w, ml, mu, s, x): 

105 return ml + x/float(n) * (w - (ml + mu + (n-1)*s)) + (math.floor(x)-1) * s 

106 

107 

108def make_smap(cmap, norm=None): 

109 if isinstance(norm, tuple): 

110 norm = colors.Normalize(*norm, clip=False) 

111 smap = cm.ScalarMappable(cmap=cmap, norm=norm) 

112 smap._A = [] # not needed in newer versions of mpl? 

113 return smap 

114 

115 

116def solve_layout_fixed_panels(size, shape, limits, aspects, fracs=None): 

117 

118 weight_aspect = 1000. 

119 

120 sx, sy = size 

121 nx, ny = shape 

122 nvar = nx+ny 

123 vxs, vys = limits 

124 uxs = vxs[:, 1] - vxs[:, 0] 

125 uys = vys[:, 1] - vys[:, 0] 

126 aspects_xx, aspects_yy, aspects_xy = aspects 

127 

128 if fracs is None: 

129 wxs = num.full(nx, sx / nx) 

130 wys = num.full(ny, sy / ny) 

131 else: 

132 frac_x, frac_y = fracs 

133 wxs = sx * frac_x / num.sum(frac_x) 

134 wys = sy * frac_y / num.sum(frac_y) 

135 

136 data = [] 

137 weights = [] 

138 rows = [] 

139 bounds = [] 

140 for ix in range(nx): 

141 u = uxs[ix] 

142 assert u > 0.0 

143 row = num.zeros(nvar) 

144 row[ix] = u 

145 rows.append(row) 

146 data.append(wxs[ix]) 

147 weights.append(1.0 / u) 

148 bounds.append((0, wxs[ix] / u)) 

149 

150 for iy in range(ny): 

151 u = uys[iy] 

152 assert u > 0.0 

153 row = num.zeros(nvar) 

154 row[nx+iy] = u 

155 rows.append(row) 

156 data.append(wys[iy]) 

157 weights.append(1.0) 

158 bounds.append((0, wys[iy] / u)) 

159 

160 for ix1, ix2, aspect in aspects_xx: 

161 row = num.zeros(nvar) 

162 row[ix1] = aspect 

163 row[ix2] = -1.0 

164 weights.append(weight_aspect/aspect) 

165 rows.append(row) 

166 data.append(0.0) 

167 

168 for iy1, iy2, aspect in aspects_yy: 

169 row = num.zeros(nvar) 

170 row[nx+iy1] = aspect 

171 row[nx+iy2] = -1.0 

172 weights.append(weight_aspect/aspect) 

173 rows.append(row) 

174 data.append(0.0) 

175 

176 for ix, iy, aspect in aspects_xy: 

177 row = num.zeros(nvar) 

178 row[ix] = aspect 

179 row[nx+iy] = -1.0 

180 weights.append(weight_aspect/aspect) 

181 rows.append(row) 

182 data.append(0.0) 

183 

184 weights = num.array(weights) 

185 data = num.array(data) 

186 mat = num.vstack(rows) * weights[:, num.newaxis] 

187 data *= weights 

188 

189 bounds = num.array(bounds).T 

190 

191 model = scipy.optimize.lsq_linear(mat, data, bounds).x 

192 

193 cxs = model[:nx] 

194 cys = model[nx:nx+ny] 

195 

196 vlimits_x = num.zeros((nx, 2)) 

197 for ix in range(nx): 

198 u = wxs[ix] / cxs[ix] 

199 vmin, vmax = vxs[ix] 

200 udata = vmax - vmin 

201 eps = 1e-7 * u 

202 assert udata <= u + eps 

203 vlimits_x[ix, 0] = (vmin + vmax) / 2.0 - u / 2.0 

204 vlimits_x[ix, 1] = (vmin + vmax) / 2.0 + u / 2.0 

205 

206 vlimits_y = num.zeros((ny, 2)) 

207 for iy in range(ny): 

208 u = wys[iy] / cys[iy] 

209 vmin, vmax = vys[iy] 

210 udata = vmax - vmin 

211 eps = 1e-7 * u 

212 assert udata <= u + eps 

213 vlimits_y[iy, 0] = (vmin + vmax) / 2.0 - u / 2.0 

214 vlimits_y[iy, 1] = (vmin + vmax) / 2.0 + u / 2.0 

215 

216 def check_aspect(a, awant, eps=1e-2): 

217 if abs(1.0 - (a/awant)) > eps: 

218 logger.error( 

219 'Unable to comply with requested aspect ratio ' 

220 '(wanted: %g, achieved: %g)' % (awant, a)) 

221 

222 for ix1, ix2, aspect in aspects_xx: 

223 check_aspect(cxs[ix2] / cxs[ix1], aspect) 

224 

225 for iy1, iy2, aspect in aspects_yy: 

226 check_aspect(cys[iy2] / cys[iy1], aspect) 

227 

228 for ix, iy, aspect in aspects_xy: 

229 check_aspect(cys[iy] / cxs[ix], aspect) 

230 

231 return (vlimits_x, vlimits_y), (wxs, wys) 

232 

233 

234def solve_layout_iterative(size, shape, limits, aspects, niterations=3): 

235 

236 sx, sy = size 

237 nx, ny = shape 

238 vxs, vys = limits 

239 uxs = vxs[:, 1] - vxs[:, 0] 

240 uys = vys[:, 1] - vys[:, 0] 

241 aspects_xx, aspects_yy, aspects_xy = aspects 

242 

243 fracs_x, fracs_y = num.ones(nx), num.ones(ny) 

244 for i in range(niterations): 

245 (vlimits_x, vlimits_y), (wxs, wys) = solve_layout_fixed_panels( 

246 size, shape, limits, aspects, (fracs_x, fracs_y)) 

247 

248 uxs_view = vlimits_x[:, 1] - vlimits_x[:, 0] 

249 uys_view = vlimits_y[:, 1] - vlimits_y[:, 0] 

250 wxs_used = wxs * uxs / uxs_view 

251 wys_used = wys * uys / uys_view 

252 # wxs_wasted = wxs * (1.0 - uxs / uxs_view) 

253 # wys_wasted = wys * (1.0 - uys / uys_view) 

254 

255 fracs_x = wxs_used 

256 fracs_y = wys_used 

257 

258 return (vlimits_x, vlimits_y), (wxs, wys) 

259 

260 

261class PlotError(Exception): 

262 pass 

263 

264 

265class NotEnoughSpace(PlotError): 

266 pass 

267 

268 

269class PlotConfig(Object): 

270 ''' 

271 Configuration for :py:class:`Plot`. 

272 ''' 

273 

274 font_size = Float.T(default=9.0) 

275 

276 size_cm = Tuple.T( 

277 2, Float.T(), default=(20., 20.)) 

278 

279 margins_em = Tuple.T( 

280 4, Float.T(), default=(8., 6., 8., 6.)) 

281 

282 separator_em = Float.T(default=1.5) 

283 

284 colorbar_width_em = Float.T(default=2.0) 

285 

286 label_offset_em = Tuple.T( 

287 2, Float.T(), default=(2., 2.)) 

288 

289 tick_label_offset_em = Tuple.T( 

290 2, Float.T(), default=(0.5, 0.5)) 

291 

292 @property 

293 def size_inch(self): 

294 return self.size_cm[0]/inch, self.size_cm[1]/inch 

295 

296 

297class Plot(object): 

298 ''' 

299 Matplotlib plotting with some fancy extras. 

300 

301 - Absolute sized figure margins, also for interactive plots. 

302 - Improved label placement for grids of axes. 

303 - Improved shared axis'es across multiple axes, e.g. for cross section 

304 plots. 

305 - Fixed aspect plotting across multiple axis'es on separate axes. 

306 - Automatic subplot sizing based on aspect and data limit constraints. 

307 - Serializable plot configuration. 

308 ''' 

309 

310 def __init__( 

311 self, x_dims=['x'], y_dims=['y'], z_dims=[], config=None, 

312 fig=None, call_mpl_init=True): 

313 

314 if config is None: 

315 config = PlotConfig() 

316 

317 self._shape = len(x_dims), len(y_dims) 

318 

319 dims = [] 

320 for dim in x_dims + y_dims + z_dims: 

321 dim = dim.lstrip('-') 

322 if dim not in dims: 

323 dims.append(dim) 

324 

325 self.config = config 

326 self._disconnect_data = [] 

327 self._width = self._height = self._pixels = None 

328 if call_mpl_init: 

329 self._plt = plot.mpl_init(self.config.font_size) 

330 

331 if fig is None: 

332 fig = self._plt.figure( 

333 figsize=self.config.size_inch, FigureClass=SmartplotFigure) 

334 else: 

335 assert isinstance(fig, SmartplotFigure) 

336 

337 fig.set_smartplot(self) 

338 

339 self._fig = fig 

340 self._colorbar_width = 0.0 

341 self._colorbar_height = 0.0 

342 self._colorbar_axes = [] 

343 

344 self._dims = dims 

345 self._dim_index = self._dims.index 

346 self._ndims = len(dims) 

347 self._labels = {} 

348 self._aspects = {} 

349 

350 self.setup_axes() 

351 

352 self._view_limits = num.zeros((self._ndims, 2)) 

353 

354 self._view_limits[:, :] = num.nan 

355 self._last_mpl_view_limits = None 

356 

357 self._x_dims = [dim.lstrip('-') for dim in x_dims] 

358 self._x_dims_invert = [dim.startswith('-') for dim in x_dims] 

359 

360 self._y_dims = [dim.lstrip('-') for dim in y_dims] 

361 self._y_dims_invert = [dim.startswith('-') for dim in y_dims] 

362 

363 self._z_dims = [dim.lstrip('-') for dim in z_dims] 

364 self._z_dims_invert = [dim.startswith('-') for dim in z_dims] 

365 

366 self._mappables = {} 

367 self._updating_layout = False 

368 

369 self._need_update_layout = True 

370 self._update_geometry() 

371 

372 for axes in self.axes_list: 

373 fig.add_axes(axes) 

374 self._connect(axes, 'xlim_changed', self.lim_changed_handler) 

375 self._connect(axes, 'ylim_changed', self.lim_changed_handler) 

376 

377 self._cid_resize = fig.canvas.mpl_connect( 

378 'resize_event', self.resize_handler) 

379 

380 try: 

381 self._connect(fig, 'dpi_changed', self.dpi_changed_handler) 

382 except ValueError: 

383 # 'dpi_changed' event has been removed in MPL 3.8. 

384 # canvas 'resize_event' may be sufficient but needs to be checked. 

385 # https://matplotlib.org/stable/api/prev_api_changes/api_changes_3.8.0.html#text-get-rotation 

386 pass 

387 

388 self._lim_changed_depth = 0 

389 

390 def reset_size(self): 

391 self._fig.set_size_inches(self.config.size_inch) 

392 

393 def axes(self, ix, iy): 

394 if not (isinstance(ix, int) and isinstance(iy, int)): 

395 ix = self._x_dims.index(ix) 

396 iy = self._y_dims.index(iy) 

397 

398 return self._axes[iy][ix] 

399 

400 def set_color_dim(self, mappable, dim): 

401 assert dim in self._dims 

402 self._mappables[mappable] = dim 

403 

404 def set_aspect(self, ydim, xdim, aspect=1.0): 

405 self._aspects[ydim, xdim] = aspect 

406 

407 @property 

408 def dims(self): 

409 return self._dims 

410 

411 @property 

412 def fig(self): 

413 return self._fig 

414 

415 @property 

416 def axes_list(self): 

417 axes = [] 

418 for row in self._axes: 

419 axes.extend(row) 

420 return axes 

421 

422 @property 

423 def axes_bottom_list(self): 

424 return self._axes[0] 

425 

426 @property 

427 def axes_left_list(self): 

428 return [row[0] for row in self._axes] 

429 

430 def setup_axes(self): 

431 rect = [0., 0., 1., 1.] 

432 nx, ny = self._shape 

433 axes = [] 

434 for iy in range(ny): 

435 axes.append([]) 

436 for ix in range(nx): 

437 axes[-1].append(SmartplotAxes(self.fig, rect)) 

438 

439 self._axes = axes 

440 

441 for _, _, axes_ in self.iaxes(): 

442 axes_.set_autoscale_on(False) 

443 

444 def _connect(self, obj, sig, handler): 

445 cid = get_callbacks(obj).connect(sig, handler) 

446 self._disconnect_data.append((obj, cid)) 

447 

448 def _disconnect_all(self): 

449 for obj, cid in self._disconnect_data: 

450 get_callbacks(obj).disconnect(cid) 

451 

452 self._fig.canvas.mpl_disconnect(self._cid_resize) 

453 

454 def dpi_changed_handler(self, fig): 

455 if self._updating_layout: 

456 return 

457 

458 self._update_geometry() 

459 

460 def resize_handler(self, event): 

461 if self._updating_layout: 

462 return 

463 

464 self._update_geometry() 

465 

466 def lim_changed_handler(self, axes): 

467 if self._updating_layout: 

468 return 

469 

470 current = self._get_mpl_view_limits() 

471 last = self._last_mpl_view_limits 

472 if last is None: 

473 return 

474 

475 for iy, ix, axes in self.iaxes(): 

476 acurrent = current[iy][ix] 

477 alast = last[iy][ix] 

478 if acurrent[0] != alast[0]: 

479 xdim = self._x_dims[ix] 

480 logger.debug( 

481 'X limits have been changed interactively in subplot ' 

482 '(%i, %i)' % (ix, iy)) 

483 self.set_lim(xdim, *sorted(acurrent[0])) 

484 

485 if acurrent[1] != alast[1]: 

486 ydim = self._y_dims[iy] 

487 logger.debug( 

488 'Y limits have been changed interactively in subplot ' 

489 '(%i, %i)' % (ix, iy)) 

490 self.set_lim(ydim, *sorted(acurrent[1])) 

491 

492 def _update_geometry(self): 

493 w, h = self._fig.canvas.get_width_height() 

494 dp = self.get_device_pixel_ratio() 

495 p = self.get_pixels_factor() * dp 

496 

497 if (self._width, self._height, self._pixels) != (w, h, p, dp): 

498 logger.debug( 

499 'New figure size: %g x %g, ' 

500 'logical-pixel/point: %g, physical-pixel/logical-pixel: %g' % ( 

501 w, h, p, dp)) 

502 

503 self._width = w # logical pixel 

504 self._height = h # logical pixel 

505 self._pixels = p # logical pixel / point 

506 self._device_pixel_ratio = dp # physical / logical 

507 self.need_update_layout() 

508 

509 @property 

510 def margins(self): 

511 return tuple( 

512 x * self.config.font_size / self._pixels 

513 for x in self.config.margins_em) 

514 

515 @property 

516 def separator(self): 

517 return self.config.separator_em * self.config.font_size / self._pixels 

518 

519 def rect_to_figure_coords(self, rect): 

520 left, bottom, width, height = rect 

521 return ( 

522 left / self._width, 

523 bottom / self._height, 

524 width / self._width, 

525 height / self._height) 

526 

527 def point_to_axes_coords(self, axes, point): 

528 x, y = point 

529 aleft, abottom, awidth, aheight = axes.get_position().bounds 

530 

531 x_fig = x / self._width 

532 y_fig = y / self._height 

533 

534 x_axes = (x_fig - aleft) / awidth 

535 y_axes = (y_fig - abottom) / aheight 

536 

537 return (x_axes, y_axes) 

538 

539 def get_pixels_factor(self): 

540 try: 

541 r = self._fig.canvas.get_renderer() 

542 return 1.0 / r.points_to_pixels(1.0) 

543 except AttributeError: 

544 return 1.0 

545 

546 def get_device_pixel_ratio(self): 

547 try: 

548 return self._fig.canvas.device_pixel_ratio 

549 except AttributeError: 

550 return 1.0 

551 

552 def make_limits(self, lims): 

553 a = plot.AutoScaler(space=0.05) 

554 return a.make_scale(lims)[:2] 

555 

556 def iaxes(self): 

557 for iy, row in enumerate(self._axes): 

558 for ix, axes in enumerate(row): 

559 yield iy, ix, axes 

560 

561 def get_data_limits(self): 

562 dim_to_values = defaultdict(list) 

563 for iy, ix, axes in self.iaxes(): 

564 dim_to_values[self._y_dims[iy]].extend( 

565 axes.get_yaxis().get_data_interval()) 

566 dim_to_values[self._x_dims[ix]].extend( 

567 axes.get_xaxis().get_data_interval()) 

568 

569 for mappable, dim in self._mappables.items(): 

570 dim_to_values[dim].extend(mappable.get_clim()) 

571 

572 lims = num.zeros((self._ndims, 2)) 

573 for idim in range(self._ndims): 

574 dim = self._dims[idim] 

575 if dim in dim_to_values: 

576 vs = num.array( 

577 dim_to_values[self._dims[idim]], dtype=float) 

578 vs = vs[num.isfinite(vs)] 

579 if vs.size > 0: 

580 lims[idim, :] = num.min(vs), num.max(vs) 

581 else: 

582 lims[idim, :] = num.nan, num.nan 

583 else: 

584 lims[idim, :] = num.nan, num.nan 

585 

586 lims[num.logical_not(num.isfinite(lims))] = 0.0 

587 return lims 

588 

589 def set_lim(self, dim, vmin, vmax): 

590 assert vmin <= vmax 

591 self._view_limits[self._dim_index(dim), :] = vmin, vmax 

592 self.need_update_layout() 

593 

594 def set_x_invert(self, ix, invert): 

595 self._x_dims_invert[ix] = invert 

596 self.need_update_layout() 

597 

598 def set_y_invert(self, iy, invert): 

599 self._y_dims_invert[iy] = invert 

600 self.need_update_layout() 

601 

602 def _get_mpl_view_limits(self): 

603 vl = [] 

604 for row in self._axes: 

605 vl_row = [] 

606 for axes in row: 

607 vl_row.append(( 

608 axes.get_xaxis().get_view_interval().tolist(), 

609 axes.get_yaxis().get_view_interval().tolist())) 

610 

611 vl.append(vl_row) 

612 

613 return vl 

614 

615 def _remember_mpl_view_limits(self): 

616 self._last_mpl_view_limits = self._get_mpl_view_limits() 

617 

618 def window_xmin(self, x): 

619 return window_min( 

620 self._shape[0], self._width, 

621 self.margins[0], self.margins[2] + self._colorbar_width, 

622 self.separator, x) 

623 

624 def window_xmax(self, x): 

625 return window_max( 

626 self._shape[0], self._width, 

627 self.margins[0], self.margins[2] + self._colorbar_width, 

628 self.separator, x) 

629 

630 def window_ymin(self, y): 

631 return window_min( 

632 self._shape[1], self._height, 

633 self.margins[3] + self._colorbar_height, self.margins[1], 

634 self.separator, y) 

635 

636 def window_ymax(self, y): 

637 return window_max( 

638 self._shape[1], self._height, 

639 self.margins[3] + self._colorbar_height, self.margins[1], 

640 self.separator, y) 

641 

642 def need_update_layout(self): 

643 self._need_update_layout = True 

644 

645 def _update_layout(self): 

646 assert not self._updating_layout 

647 

648 if not self._need_update_layout: 

649 return 

650 

651 self._updating_layout = True 

652 try: 

653 data_limits = self.get_data_limits() 

654 

655 limits = num.zeros((self._ndims, 2)) 

656 for idim in range(self._ndims): 

657 limits[idim, :] = self.make_limits(data_limits[idim, :]) 

658 

659 mask = num.isfinite(self._view_limits) 

660 limits[mask] = self._view_limits[mask] 

661 

662 # deltas = limits[:, 1] - limits[:, 0] 

663 

664 # data_w = deltas[0] 

665 # data_h = deltas[1] 

666 

667 ml, mt, mr, mb = self.margins 

668 mr += self._colorbar_width 

669 mb += self._colorbar_height 

670 sw = sh = self.separator 

671 

672 nx, ny = self._shape 

673 

674 # data_r = data_h / data_w 

675 em = self.config.font_size 

676 em_pixels = em / self._pixels 

677 w = self._width 

678 h = self._height 

679 fig_w_avail = w - mr - ml - (nx-1) * sw 

680 fig_h_avail = h - mt - mb - (ny-1) * sh 

681 

682 if fig_w_avail <= 0.0 or fig_h_avail <= 0.0: 

683 raise NotEnoughSpace() 

684 

685 x_limits = num.zeros((nx, 2)) 

686 for ix, xdim in enumerate(self._x_dims): 

687 x_limits[ix, :] = limits[self._dim_index(xdim)] 

688 

689 y_limits = num.zeros((ny, 2)) 

690 for iy, ydim in enumerate(self._y_dims): 

691 y_limits[iy, :] = limits[self._dim_index(ydim)] 

692 

693 def get_aspect(dim1, dim2): 

694 if (dim2, dim1) in self._aspects: 

695 return 1.0/self._aspects[dim2, dim1] 

696 

697 return self._aspects.get((dim1, dim2), None) 

698 

699 aspects_xx = [] 

700 for ix1, xdim1 in enumerate(self._x_dims): 

701 for ix2, xdim2 in enumerate(self._x_dims): 

702 aspect = get_aspect(xdim2, xdim1) 

703 if aspect: 

704 aspects_xx.append((ix1, ix2, aspect)) 

705 

706 aspects_yy = [] 

707 for iy1, ydim1 in enumerate(self._y_dims): 

708 for iy2, ydim2 in enumerate(self._y_dims): 

709 aspect = get_aspect(ydim2, ydim1) 

710 if aspect: 

711 aspects_yy.append((iy1, iy2, aspect)) 

712 

713 aspects_xy = [] 

714 for iy, ix, axes in self.iaxes(): 

715 xdim = self._x_dims[ix] 

716 ydim = self._y_dims[iy] 

717 aspect = get_aspect(ydim, xdim) 

718 if aspect: 

719 aspects_xy.append((ix, iy, aspect)) 

720 

721 (x_limits, y_limits), (aws, ahs) = solve_layout_iterative( 

722 size=(fig_w_avail, fig_h_avail), 

723 shape=(nx, ny), 

724 limits=(x_limits, y_limits), 

725 aspects=( 

726 aspects_xx, 

727 aspects_yy, 

728 aspects_xy)) 

729 

730 for iy, ix, axes in self.iaxes(): 

731 rect = [ 

732 ml + num.sum(aws[:ix])+(ix*sw),