Re: [eigen] gdb pretty quaternion and vector printing |
[ Thread Index |
Date Index
| More lists.tuxfamily.org/eigen Archives
]
- To: eigen@xxxxxxxxxxxxxxxxxxx
- Subject: Re: [eigen] gdb pretty quaternion and vector printing
- From: Benoit Jacob <jacob.benoit.1@xxxxxxxxx>
- Date: Tue, 20 Apr 2010 16:25:53 -0400
- Cc: bschindler@xxxxxxxxxxx
- Dkim-signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:in-reply-to:references :date:received:message-id:subject:from:to:cc:content-type :content-transfer-encoding; bh=VYTxTl8KJU1nriYrlgHWDPhrertdkdmzKqH12ic6aX4=; b=GYq3JyaXS0LbjXqsmpb3jaBx3qLAk3SEAJ7yQnebfUozpKsDrzQv0R/9+O2S6i4GeI j9T8RRwRYzU+4BOCrK++qytT3tPoewUgO0fEzcq7Q8M7+xaD1fBV14orDlh+pHr43AQh ZaSoen//BDtxjmFPNb0ytecbxjipMi6hvhkAk=
- Domainkey-signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:content-transfer-encoding; b=IFnJp5ecopekH4XLHb8Mm/pFWedn8D8liXqVO6ODfavTSF3du3MF9w8bOGRMvNGSKX Wyc5aNjxTu0aygwdzBRUtna0xUjye+ZYLABBwub3e+WlPA+mW/6vzZ+tDbSOBdzNSswG 2RcEaBMcEGqAaA6Q1I98sQPvK8hdh8Ol+nkSI=
Very nice contribution!
Could you make a proper patch as explained here:
http://eigen.tuxfamily.org/index.php?title=Developer's_Corner#Generating_a_patch
This gets you credited and spares us the effort.
Benjamin, can you confirm that this is OK for you ? and works for you ?
Thanks,
Benoit
2010/4/20 Daniel Lowengrub <lowdanie@xxxxxxxxx>:
> Hi,
> I've been using the gdb-python pretty printing support as described here:
> http://listengine.tuxfamily.org/lists.tuxfamily.org/eigen/2009/12/msg00066.html
> I added two things to the printers.py file:
> 1) When the type is has a single column or row then the variable is
> displayed as a vector like this:
> [0] = x
> [1] = y
> ...
> instead of the current:
> [0,0] = x
> [1,0] = y
> ...
>
> 2) Support for quaternions has been added. They output looks like this:
> Eigen::Quaternion<double> (data ptr: 0xbffff440) = {
> [x] = 0.0079
> [y] = 0.0345
> [z] = 0.0364
> [w] = 0.9942}
>
> Cheers,
> Daniel Lowengrub
> ------------------------------------
>
> import gdb
> import re
> import itertools
>
>
> class EigenMatrixPrinter:
> "Print Eigen Matrix of some kind"
>
> def __init__(self, val):
> "Extract all the necessary information"
> # The gdb extension does not support value template arguments - need
> to extract them by hand
> type = val.type
> if type.code == gdb.TYPE_CODE_REF:
> type = type.target()
> self.type = type.unqualified().strip_typedefs()
> tag = self.type.tag
> regex = re.compile('\<.*\>')
> m = regex.findall(tag)[0][1:-1]
> template_params = m.split(',')
> template_params = map(lambda x:x.replace(" ", ""), template_params)
>
> self.rows = int(template_params[1])
> self.cols = int(template_params[2])
> self.options = 0 # default value
> if len(template_params) > 3:
> self.options = template_params[3];
>
> self.rowMajor = (int(self.options) & 0x1)
>
> if self.rows == 10000:
> self.rows = val['m_storage']['m_rows']
>
> if self.cols == 10000:
> self.cols = val['m_storage']['m_cols']
>
> self.innerType = self.type.template_argument(0)
>
> self.val = val
>
> # Fixed size matrices have a struct as their storage, so we need to
> walk through this
> self.data = self.val['m_storage']['m_data']
> if self.data.type.code == gdb.TYPE_CODE_STRUCT:
> self.data = self.data['array']
> self.data = self.data.cast(self.innerType.pointer())
>
> class _iterator:
> def __init__ (self, rows, cols, dataPtr, rowMajor):
> self.rows = rows
> self.cols = cols
> self.dataPtr = dataPtr
> self.currentRow = 0
> self.currentCol = 0
> self.rowMajor = rowMajor
>
> def __iter__ (self):
> return self
>
> def next(self):
>
> row = self.currentRow
> col = self.currentCol
> if self.rowMajor == 0:
> if self.currentCol >= self.cols:
> raise StopIteration
>
> self.currentRow = self.currentRow + 1
> if self.currentRow >= self.rows:
> self.currentRow = 0
> self.currentCol = self.currentCol + 1
> else:
> if self.currentRow >= self.rows:
> raise StopIteration
>
> self.currentCol = self.currentCol + 1
> if self.currentCol >= self.cols:
> self.currentCol = 0
> self.currentRow = self.currentRow + 1
>
>
> item = self.dataPtr.dereference()
> self.dataPtr = self.dataPtr + 1
> if (self.cols == 1): #if it's a column vector
> return ('[%d]' % (row,), item)
> elif (self.rows == 1): #if it's a row vector
> return ('[%d]' % (col,), item)
> return ('[%d,%d]' % (row, col), item)
>
> def children(self):
>
> return self._iterator(self.rows, self.cols, self.data, self.rowMajor)
>
> def to_string(self):
> return "Eigen::Matrix<%s,%d,%d,%s> (data ptr: %s)" %
> (self.innerType, self.rows, self.cols, "RowMajor" if self.rowMajor
> else "ColMajor", self.data)
>
> class EigenQuaternionPrinter:
> "Print an Eigen Quaternion"
>
> def __init__(self, val):
> "Extract all the necessary information"
> # The gdb extension does not support value template arguments - need
> to extract them by hand
> type = val.type
> if type.code == gdb.TYPE_CODE_REF:
> type = type.target()
> self.type = type.unqualified().strip_typedefs()
> self.innerType = self.type.template_argument(0)
> self.val = val
>
> # Quaternions have a struct as their storage, so we need to walk through this
> self.data = self.val['m_coeffs']['m_storage']['m_data']['array']
> self.data = self.data.cast(self.innerType.pointer())
>
> class _iterator:
> def __init__ (self, dataPtr):
> self.dataPtr = dataPtr
> self.currentElement = 0
> self.elementNames = ['x', 'y', 'z', 'w']
>
> def __iter__ (self):
> return self
>
> def next(self):
> element = self.currentElement
>
> if self.currentElement >= 4: #there are 4 elements in a quanternion
> raise StopIteration
>
> self.currentElement = self.currentElement + 1
>
> item = self.dataPtr.dereference()
> self.dataPtr = self.dataPtr + 1
> return ('[%s]' % (self.elementNames[element],), item)
>
> def children(self):
>
> return self._iterator(self.data)
>
> def to_string(self):
> return "Eigen::Quaternion<%s> (data ptr: %s)" % (self.innerType, self.data)
>
> def build_eigen_dictionary ():
> pretty_printers_dict[re.compile('^Eigen::Quaternion<.*>$')] = lambda
> val: EigenQuaternionPrinter(val)
> pretty_printers_dict[re.compile('^Eigen::Matrix<.*>$')] = lambda val:
> EigenMatrixPrinter(val)
>
> def register_eigen_printers(obj):
> "Register eigen pretty-printers with objfile Obj"
>
> if obj == None:
> obj = gdb
> obj.pretty_printers.append(lookup_function)
>
> def lookup_function(val):
> "Look-up and return a pretty-printer that can print va."
>
> type = val.type
>
> if type.code == gdb.TYPE_CODE_REF:
> type = type.target()
>
> type = type.unqualified().strip_typedefs()
>
> typename = type.tag
> if typename == None:
> return None
>
> for function in pretty_printers_dict:
> if function.search(typename):
> return pretty_printers_dict[function](val)
>
> return None
>
> pretty_printers_dict = {}
>
> build_eigen_dictionary ()
>
>
>