Inheritance diagram for lsst.gdb.afw.printers.GdbOptionParser.PrintImageCommand:

Public Member Functions
	__init__ (self)

	get (self, var, x, y)

	invoke (self, args, fromTty)

Detailed Description

Print an Image

Definition at line 508 of file printers.py.

Constructor & Destructor Documentation

◆ init()

lsst.gdb.afw.printers.GdbOptionParser.PrintImageCommand.__init__ ( self )

Definition at line 511 of file printers.py.

        def __init__(self):
            super(PrintImageCommand, self).__init__("show image",
                                                    gdb.COMMAND_DATA,
                                                    gdb.COMPLETE_SYMBOL)
 

Member Function Documentation

◆ get()

lsst.gdb.afw.printers.GdbOptionParser.PrintImageCommand.get	(	self,
		var,
		x,
		y )

Definition at line 516 of file printers.py.

        def get(self, var, x, y):
            if False:
                return var["operator()(int, int, bool)"](x, y, True)
            else:
                dimensions = var["_gilView"]["_dimensions"]
                if x < 0 or x >= dimensions["x"] or y < 0 or y >= dimensions["y"]:
                    raise gdb.GdbError("Pixel (%d, %d) is out of range 0:%d, 0:%d" %
                                       (x, y, dimensions["x"] - 1, dimensions["y"] - 1))
 
                pixels = var["_gilView"]["_pixels"]["_p"]
                step = pixels["_step_fn"]["_step"] / \
                    var.type.template_argument(0).sizeof
 
                return pixels["m_iterator"][x + y*step]["_v0"]
 

◆ invoke()

lsst.gdb.afw.printers.GdbOptionParser.PrintImageCommand.invoke	(	self,
		args,
		fromTty )

Definition at line 531 of file printers.py.

        def invoke(self, args, fromTty):
            self.dont_repeat()
 
            parser = GdbOptionParser(
                "show image" + ("" if argparse else " <image> [<nx> [<ny>]]"))
            parser.add_option("-a", "--all", action="store_true",
                              help="Display the whole image/mask")
            parser.add_option("-c", "--center", type="str", nargs=2, default=(None, None,),
                              help="Center the output at (x, y)")
            parser.add_option("-o", "--origin", type="str", nargs=2, default=(None, None,),
                              help="Print the region starting at (x, y)")
            parser.add_option("-x", "--xy0", action="store_true",
                              help="Obey the image's (x0, y0)")
            parser.add_option("-f", "--formatWidth", type="int",
                              default=8, help="Field width for values")
            parser.add_option("-d", "--dataFmt", default="%.2f",
                              help="Format for values")
 
            if argparse:
                parser.add_option(
                    "image", help="Expression giving image to show")
                parser.add_option(
                    "width", help="Width of patch to print", default=1, nargs="?")
                parser.add_option(
                    "height", help="Height of patch to print", default=1, nargs="?")
 
                opts = parser.parse_args(args)
                if opts.help:
                    return
            else:
                opts, args = parser.parse_args(args)
                if opts.help:
                    return
 
                if not args:
                    raise gdb.GdbError("Please specify an image")
 
                opts.image = args.pop(0)
 
                opts.width, opts.height = 1, 1
                if args:
                    opts.width = int(args.pop(0))
                if args:
                    opts.height = int(args.pop(0))
 
                if args:
                    raise gdb.GdbError(
                        "Unrecognised trailing arguments: %s" % " ".join(args))
 
            for i in range(2):
                val = "0"
                if opts.origin[i] is None:
                    if opts.center[i] is not None:
                        val = opts.center[i]
                else:
                    val = opts.origin[i]
                    if opts.center[i] is not None:
                        raise gdb.GdbError(
                            "You may not specify both --center and --origin")
 
                val = gdb.parse_and_eval(val)
                if i == 0:
                    x0 = val
                else:
                    y0 = val
 
            if opts.all:
                nx, ny = 0, 0
            else:
                nx, ny = opts.width, opts.height
 
            var = gdb.parse_and_eval(opts.image)
 
            if re.search(r"shared_ptr<", str(var.type)):
                var = var["px"].dereference()
 
            if not re.search(r"(lsst::afw::image::)?(Image|Mask|MaskedImage)", str(var.type.unqualified())):
                raise gdb.GdbError(
                    "Please specify an image, not %s" % var.type)
 
            if re.search(r"MaskedImage", str(var.type)) and \
                    not re.search(r"::Image(\s*&)?$", str(var.type)):
                print("N.b. %s is a MaskedImage; showing image" % (opts.image))
                var = var["_image"]
 
            if re.search(r"shared_ptr<", str(var.type)):
                var = var["px"].dereference()
 
            if var.type.code == gdb.TYPE_CODE_PTR:
                var = var.dereference()     # be nice
 
            pixelTypeName = str(var.type.template_argument(0))
            if opts.dataFmt:
                dataFmt = opts.dataFmt
            elif pixelTypeName in ["short", "unsigned short"]:
                dataFmt = "0x%x"
            elif pixelTypeName in ["int", "unsigned int"]:
                dataFmt = "%d"
            else:
                dataFmt = "%.2f"
 
            if nx == 0:
                nx = var["_gilView"]["_dimensions"]["x"]
            if ny == 0:
                ny = var["_gilView"]["_dimensions"]["y"]
 
            if opts.center[0]:
                x0 -= nx//2
                y0 -= ny//2
 
            if opts.xy0 and not opts.all:
                arr = var["_origin"]["_vector"]["m_storage"]["m_data"]["array"]
 
                x0 -= arr[0]
                y0 -= arr[1]
            #
            # OK, finally time to print
            #
            print("%-4s" % "", end=' ')
            for x in range(x0, x0 + nx):
                print("%*d" % (opts.formatWidth, x), end=' ')
            print("")
 
            for y in reversed(list(range(y0, y0 + ny))):
                print("%-4d" % y, end=' ')
                for x in range(x0, x0 + nx):
                    print("%*s" % (opts.formatWidth, dataFmt %
                                   self.get(var, x, y)), end=' ')
                print("")
 
    PrintImageCommand()

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/g7b55021d1b+7b623691d5/python/lsst/gdb/afw/printers.py