def read_3D_java(sizeF1, sizeF2, sizeF3, filename="ser"):
"""
Reads in a Bruker 3D fid
sizeF1 x sizeF2 is the number of fid
sizeF3 is the number of data-points in the fid
uses java low level file access
"""
from java.io import RandomAccessFile
# from nmrtec.util.IO import SwapByte
import jarray
# read binary
dim(3)
chsize(int(sizeF1), int(sizeF2), int(sizeF3))
f = RandomAccessFile(filename, "r")
for i1 in range(sizeF1):
print(i1, end=' ')
for i2 in range(sizeF2):
for i3 in range(sizeF3):
x = f.readInt()
# x = SwapByte.swap(x) # uncoment if swapbyte is required
setval(i1 + 1, i2 + 1, i3 + 1, float(x)) # copy to 3D buffer
if ((sizeF3 % 256) != 0
): # pb with Bruker files, where size is always a 256 multiple
for i3 in range(((sizeF3 / 256) + 1) * 256 - sizeF3):
x = f.readInt()
def parse_TIFF_IFDs(filepath):
""" Returns a generator of dictionaries of tags for each IFD in the TIFF file,
as defined by the 'parseIFD' function above. """
ra = RandomAccessFile(filepath, 'r')
try:
# TIFF file format can have metadata at the end after the images, so the above approach can fail
# TIFF file header is 8-bytes long:
# (See: http://paulbourke.net/dataformats/tiff/tiff_summary.pdf )
#
# Bytes 1 and 2: identifier. Either the value 4949h (II) or 4D4Dh (MM),
# meaning little-endian and big-endian, respectively.
# All data encountered past the first two bytes in the file obey
# the byte-ordering scheme indicated by the identifier field.
b1, b2 = ra.read(), ra.read() # as two java int, each one byte sized
bigEndian = chr(b1) == 'M'
parseNextInt = parseNextIntBigEndian if bigEndian else parseNextIntLittleEndian
# Bytes 3 and 4: Version: Always 42
ra.skipBytes(2)
# Bytes 5,6,7,8: IFDOffset: offset to first image file directory (IFD), the metadata entry for the first image.
nextIFDoffset = parseNextInt(ra, 4) # offset to first IFD
while nextIFDoffset != 0:
ra.seek(nextIFDoffset)
tags, nextIFDoffset = parseIFD(ra, parseNextInt)
tags["bigEndian"] = bigEndian
yield tags
finally:
ra.close()
def get(self, index):
IFD = self.IFDs[index]
ra = RandomAccessFile(self.filepath, 'r')
try:
cell_position = [0, 0, index]
pixels = read_TIFF_plane(ra, IFD) # a native array
access = self.types[IFD["bitDepth"]][0] # e.g. ByteArray, FloatArray ...
return Cell(self.cell_dimensions, cell_position, access(pixels))
finally:
ra.close()
def updateCmdForDeltaScanning(commandLine, Framework):
originalScanFileFolderPath = CollectorsParameters.PROBE_MGR_INVENTORY_XMLENRICHER_FILES_FOLDER + XmlEnricherConstants.ORIGINAL_FOLDER_NAME
originalScanFile = File(originalScanFileFolderPath, InventoryUtils.generateScanFileName(Framework))
if originalScanFile.exists():
scan = None
try:
try:
buffer = jarray.zeros(0x24, 'b')
fileSize = originalScanFile.length()
if fileSize > 0x24:
scan = RandomAccessFile(originalScanFile, "r")
scan.readFully(buffer)
if (buffer[0] == 0x1F) and ((buffer[1] & 0xFF) == 0x8B) and (buffer[2] == 0x08):
scan.seek(fileSize - 8)
scan.readFully(buffer, 0, 8)
crc32 = getInt(buffer, 0)
size = getInt(buffer, 4)
deltaParams = ' -oldscanid:' + str(crc32) + ' -oldscansize:' + str(size) + ' '
index = String(commandLine).indexOf(ENTERPRISE_MODE) + String(ENTERPRISE_MODE).length()
commandLine = commandLine[0:index] + deltaParams + commandLine[index + 1:]
logger.debug('Scanner execution command updated to ', commandLine)
except:
logger.debugException("Failed to calculate CRC32 and size of zipped scan file " + originalScanFile.getAbsolutePath())
finally:
if scan is not None:
try:
scan.close()
except:
pass
return commandLine
def read2DImageROI(path, dimensions, interval, pixelType=UnsignedShortType, header=0, byte_order=ByteOrder.LITTLE_ENDIAN):
""" Read a region of interest (the interval) of an image in a file.
Assumes the image is written with the first dimension moving slowest.
path: the file path to the image file.
dimensions: a sequence of integer values e.g. [512, 512, 512]
interval: two sequences of integer values defining the min and max coordinates, e.g.
[[20, 0], [400, 550]]
pixeltype: e.g. UnsignedShortType, FloatType
header: defaults to zero, the number of bytes between the start of the file and the start of the image data.
Supports only these types: UnsignedByteType, UnsignedShortType, FloatType.
Returns an ArrayImg of the given type.
"""
ra = RandomAccessFile(path, 'r')
try:
width, height = dimensions
minX, minY = interval[0]
maxX, maxY = interval[1]
roi_width, roi_height = maxX - minX + 1, maxY - minY + 1
tailX = width - roi_width - minX
#print minX, minY
#print maxX, maxY
#print roi_width, roi_height
size = roi_width * roi_height
n_bytes_per_pixel = pixelType().getBitsPerPixel() / 8
#print n_bytes_per_pixel
bytes = zeros(size * n_bytes_per_pixel, 'b')
# Read only the 2D ROI
ra.seek(header + (minY * width + minX) * n_bytes_per_pixel)
for h in xrange(roi_height):
ra.readFully(bytes, h * roi_width * n_bytes_per_pixel, roi_width * n_bytes_per_pixel)
ra.skipBytes((tailX + minX) * n_bytes_per_pixel)
# Make an image
roiDims = [roi_width, roi_height]
if UnsignedByteType == pixelType:
return ArrayImgs.unsignedBytes(bytes, roiDims)
if UnsignedShortType == pixelType:
shorts = zeros(size, 'h')
ByteBuffer.wrap(bytes).order(byte_order).asShortBuffer().get(shorts)
return ArrayImgs.shorts(shorts, roiDims)
if FloatType == pixelType:
floats = zeros(size, 'f')
ByteBuffer.wrap(bytes).order(byte_order).asFloatBuffer().get(floats)
return ArrayImgs.floats(floats, roiDims)
finally:
ra.close()
def get(self, index):
ra = None
try:
# Read cell origin and dimensions for cell at index
cellMin = zeros(3, 'l') # long, 3 dimensions
cellDims = zeros(3, 'i') # integer, 3 dimensions
grid.getCellDimensions(index, cellMin, cellDims)
# Unpack Cell origin (in pixel coordinates)
x, y, z = cellMin
# Unpack Cell dimensions: at margins, may be smaller than cell_width, cell_height
width, height, _ = cellDims # ignore depth: it's 1
# Read cell from file into a byte array
ra = RandomAccessFile(filepaths[z], 'r')
read_width = width * bytesPerPixel
bytes = zeros(read_width * height, 'b')
# Initial offset to the Cell origin
offset = (section_width * y + x) * bytesPerPixel
n_read = 0
n_pixels = width * height
# Read line by line
while n_read < n_pixels:
ra.seek(offset)
ra.read(bytes, n_read, read_width)
n_read += read_width
offset += section_width * bytesPerPixel
# Create a new Cell of the right pixel type
return Cell(cellDims, cellMin, createAccess(bytes, bytesPerPixel))
except:
print sys.exc_info()
finally:
if ra:
ra.close()
def get(self, index):
""" Assumes:
- uncompressed image
- one sample per pixel (one channel only)
"""
IFD = self.IFDs[index]
ra = RandomAccessFile(self.filepath, 'r')
try:
cell_dimensions = [IFD["width"], IFD["height"], 1]
cell_position = [0, 0, index]
pixels = read_TIFF_plane(ra, IFD)
return Cell(cell_dimensions, cell_position,
self.types[pixels.typecode](pixels))
finally:
ra.close()
def readBinaryMaskImg(filepath, width, height, depth, header_size):
ra = RandomAccessFile(filepath, 'r')
try:
ra.skipBytes(header_size)
bytes = zeros(width * height * depth, 'b')
ra.read(bytes)
return ArrayImgs.unsignedBytes(bytes, [width, height, depth])
finally:
ra.close()
def readUnsignedBytes(path, dimensions, header=0):
""" Read a file as an ArrayImg of UnsignedShortType """
ra = RandomAccessFile(path, 'r')
try:
if header < 0:
# Interpret from the end: useful for files with variable header lengths
# such as some types of uncompressed TIFF formats
header = ra.length() + header
ra.skipBytes(header)
bytes = zeros(reduce(operator.mul, dimensions), 'b')
ra.read(bytes)
return ArrayImgs.unsignedBytes(bytes, dimensions)
finally:
ra.close()
def getSprite(self, name):
f = RandomAccessFile(self.file, "r")
sprite = self.sprites[name]
if not sprite.decoded:
self.read_details(f, sprite)
return sprite
def __init__(self, fileToPrint):
self.fileName = fileToPrint
self.today = SimpleDateFormat("yyyy.MM.dd HH:mm").format(Date())
self.textFont = Font("Monospaced", Font.PLAIN, 12)
# We use a RandomAccessFile because Java likes to seek around and
# print pages multiple times.
self.raf = RandomAccessFile(self.fileName, "r")
# These keep track of what pages we've found so far,
# and where in the file the pages start.
# Page 0's starts out filled, and the following pages' are filled
# at the end of its predecessor.
self.pagePointers = []
self.pageAfterEnd = None
# Set the pointer for page 0.
self.pagePointers.append(self.raf.getFilePointer())
def read_1D_java(size, filename="fid"):
"""
Reads in a Bruker 1D fid
size is the number of data-points in the fid
uses java low level file access
"""
from java.io import RandomAccessFile
# from nmrtec.util.IO import SwapByte
import jarray
# read binary
dim(1)
chsize(int(size))
f = RandomAccessFile(filename, "r")
for i in range(size):
x = f.readInt()
# x = SwapByte.swap(x) # uncoment if swapbyte is required
# print i,x
setval(i + 1, float(x)) # copy to 1D buffer
def readFloats(path, dimensions, header=0, byte_order=ByteOrder.LITTLE_ENDIAN):
""" Read a file as an ArrayImg of FloatType """
size = reduce(operator.mul, dimensions)
ra = RandomAccessFile(path, 'r')
try:
if header < 0:
# Interpret from the end: useful for files with variable header lengths
# such as some types of uncompressed TIFF formats
header = ra.length() + header
ra.skipBytes(header)
bytes = zeros(size * 4, 'b')
ra.read(bytes)
floats = zeros(size, 'f')
ByteBuffer.wrap(bytes).order(byte_order).asFloatBuffer().get(floats)
return ArrayImgs.floats(floats, dimensions)
finally:
ra.close()
def readUnsignedShorts(path, dimensions, header=0, return_array=False, byte_order=ByteOrder.LITTLE_ENDIAN):
""" Read a file as an ArrayImg of UnsignedShortType """
size = reduce(operator.mul, dimensions)
ra = RandomAccessFile(path, 'r')
try:
if header < 0:
# Interpret from the end: useful for files with variable header lengths
# such as some types of uncompressed TIFF formats
header = ra.length() + header
ra.skipBytes(header)
bytes = zeros(size * 2, 'b')
ra.read(bytes)
shorts = zeros(size, 'h') # h is for short
ByteBuffer.wrap(bytes).order(byte_order).asShortBuffer().get(shorts)
return shorts if return_array else ArrayImgs.unsignedShorts(shorts, dimensions)
finally:
ra.close()
def updateCmdForDeltaScanning(commandLine, Framework):
originalScanFileFolderPath = CollectorsParameters.PROBE_MGR_INVENTORY_XMLENRICHER_FILES_FOLDER + XmlEnricherConstants.ORIGINAL_FOLDER_NAME
originalScanFile = File(originalScanFileFolderPath,
InventoryUtils.generateScanFileName(Framework))
if originalScanFile.exists():
scan = None
try:
try:
buffer = jarray.zeros(0x24, 'b')
fileSize = originalScanFile.length()
if fileSize > 0x24:
scan = RandomAccessFile(originalScanFile, "r")
scan.readFully(buffer)
if (buffer[0] == 0x1F) and (
(buffer[1] & 0xFF) == 0x8B) and (buffer[2] == 0x08):
scan.seek(fileSize - 8)
scan.readFully(buffer, 0, 8)
crc32 = getInt(buffer, 0)
size = getInt(buffer, 4)
deltaParams = ' -oldscanid:' + str(
crc32) + ' -oldscansize:' + str(size) + ' '
index = String(commandLine).indexOf(
ENTERPRISE_MODE) + String(
ENTERPRISE_MODE).length()
commandLine = commandLine[
0:index] + deltaParams + commandLine[index + 1:]
logger.debug('Scanner execution command updated to ',
commandLine)
except:
logger.debugException(
"Failed to calculate CRC32 and size of zipped scan file " +
originalScanFile.getAbsolutePath())
finally:
if scan is not None:
try:
scan.close()
except:
pass
return commandLine
def read(self, file):
f = RandomAccessFile(file, "r")
# Examine the sprites
number = self.str2num(4, f)
offset = self.str2num(4, f) - 4
free = self.str2num(4, f) - 4
self.sprites = {}
o = offset
while offset < free:
offset += self.read_name(f, offset)
def __init__(self, fileToPrint):
self.fileName = fileToPrint
self.today = SimpleDateFormat("yyyy.MM.dd HH:mm").format(Date())
self.textFont = Font("Monospaced", Font.PLAIN, 12)
# We use a RandomAccessFile because Java likes to seek around and
# print pages multiple times.
self.raf = RandomAccessFile(self.fileName, "r")
# These keep track of what pages we've found so far,
# and where in the file the pages start.
# Page 0's starts out filled, and the following pages' are filled
# at the end of its predecessor.
self.pagePointers = []
self.pageAfterEnd = None
# Set the pointer for page 0.
self.pagePointers.append(self.raf.getFilePointer())
writer = JAIWriter()
writer.setFormatName("tiff")
# See doc: https://download.java.net/media/jai/javadoc/1.1.3/jai-apidocs/com/sun/media/jai/codec/TIFFEncodeParam.html
param = TIFFEncodeParam()
param.setCompression(TIFFEncodeParam.COMPRESSION_PACKBITS)
writer.setImageEncodeParam(param)
writer.write(filepath, imp)
# Parse the test file
IFDs = list(parse_TIFF_IFDs(filepath)) # the tags of each IFD
firstIFD = IFDs[0]
print firstIFD
ra = RandomAccessFile(filepath, 'r')
try:
# Read the image plane, compressed with packbits
bytes_packedbits = zeros(sum(firstIFD["StripByteCounts"]), 'b')
index = 0
for strip_offset, strip_length in zip(firstIFD["StripOffsets"], firstIFD["StripByteCounts"]):
ra.seek(strip_offset)
ra.read(bytes_packedbits, index, strip_length)
index += strip_length
print "Compressed:", bytes_packedbits
# unpack
bytes1 = unpackBits2(bytes_packedbits, firstIFD)
bytes2 = unpackBits2(bytes_packedbits, firstIFD, use_imagereader=True)
print "Decompressed jython:", bytes1
print "Decompressed imagej:", bytes2
# Check:
def readFIBSEMdat(path, channel_index=-1, header=1024, magic_number=3555587570):
""" Read a file from Shan Xu's FIBSEM software, where two channels are interleaved.
Assumes channels are stored in 16-bit.
path: the file path to the .dat file.
channel_index: the 0-based index of the channel to parse, or -1 (default) for all.
header: defaults to a length of 1024 bytes
magic_number: defaults to that for version 8 of Shan Xu's .dat image file format.
"""
ra = RandomAccessFile(path, 'r')
try:
# Check the magic number
ra.seek(0)
if ra.readInt() & 0xffffffff != magic_number:
print "Magic number mismatch"
return None
# Read the number of channels
ra.seek(32)
numChannels = ra.readByte() & 0xff # a single byte as unsigned integer
# Parse width and height
ra.seek(100)
width = ra.readInt()
ra.seek(104)
height = ra.readInt()
print numChannels, width, height
# Read the whole interleaved pixel array
ra.seek(header)
bytes = zeros(width * height * 2 * numChannels, 'b') # 2 for 16-bit
ra.read(bytes)
print "read", len(bytes), "bytes" # takes ~2 seconds
# Parse as 16-bit array
sb = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).asShortBuffer()
shorts = zeros(width * height * numChannels, 'h')
sb.get(shorts)
# Deinterleave channels
# With Weaver: fast
channels = w.deinterleave(shorts, numChannels, channel_index)
# With python array sampling: very slow, and not just from iterating whole array once per channel
# seq = xrange(numChannels) if -1 == channel_index else [channel_index]
#channels = [shorts[i::numChannels] for i in seq]
# With clojure: extremely slow, may be using reflection unexpectedly
#channels = deinterleave.invoke(shorts, numChannels)
print len(channels)
# Shockingly, these values are signed shorts, not unsigned!
return [ArrayImgs.shorts(s, [width, height]) for s in channels]
finally:
ra.close()
ra, n) # should have the actual data, left-justified
ra.skipBytes(
4 - n
) # if any left to skip up to 12 total for the tag entry, may skip none
tags[name] = dataOffset
print "tag:", name, dataType, dataCount, dataOffset
else:
ra.skipBytes(
10) # 2 were for the tagId, 12 total for each tag entry
nextIFDoffset = parseNextInt(ra, 4)
return tags, nextIFDoffset
if filepath.endswith("tif"):
try:
ra = RandomAccessFile(filepath, 'r')
# TIFF file format can have metadata at the end after the images, so the above approach can fail
# TIFF file header is 8-bytes long:
# (See: http://paulbourke.net/dataformats/tiff/tiff_summary.pdf )
#
# Bytes 1 and 2: identifier. Either the value 4949h (II) or 4D4Dh (MM),
# meaning little-ending and big-endian, respectively.
# All data encountered past the first two bytes in the file obey
# the byte-ordering scheme indicated by the identifier field.
b1, b2 = ra.read(), ra.read() # as two java int, each one byte sized
bigEndian = chr(b1) == 'M'
parseNextInt = parseNextIntBigEndian if bigEndian else parseNextIntLittleEndian
# Bytes 3 and 4: Version: Always 42
ra.skipBytes(2)
# Bytes 5,6,7,8: IFDOffset: offset to first image file directory (IFD), the metadata entry for the first image.
firstIFDoffset = parseNextInt(ra, 4)
class JESPrintableDocument(JESPrintable):
def __init__(self, fileToPrint):
self.fileName = fileToPrint
self.today = SimpleDateFormat("yyyy.MM.dd HH:mm").format(Date())
self.textFont = Font("Monospaced", Font.PLAIN, 12)
# We use a RandomAccessFile because Java likes to seek around and
# print pages multiple times.
self.raf = RandomAccessFile(self.fileName, "r")
# These keep track of what pages we've found so far,
# and where in the file the pages start.
# Page 0's starts out filled, and the following pages' are filled
# at the end of its predecessor.
self.pagePointers = []
self.pageAfterEnd = None
# Set the pointer for page 0.
self.pagePointers.append(self.raf.getFilePointer())
def printPage(self, g, pform, pageIndex):
if pageIndex < len(self.pagePointers):
# We already know where this page starts. Seek there.
self.raf.seek(self.pagePointers[pageIndex])
elif pageIndex >= self.pageAfterEnd:
# We've found the end, and this page is after it.
return JESPrintable.NO_SUCH_PAGE
else:
# We haven't gotten here yet.
# Java will probably print each page multiple times,
# and maybe even repeat pages after their successors,
# but it should never print page n + 1 before page n.
raise RuntimeError("Printing pages out of order")
# Find our dimensions.
minX = int(pform.getImageableX() + 10)
width = int(pform.getImageableWidth() - 10)
maxX = int(minX + width)
midX = int(minX + width / 2)
minY = int(pform.getImageableY() + 12)
height = int(pform.getImageableHeight() - 12)
maxY = int(minY + height)
x, y = minX, minY
# Title lines
g.setColor(Color.black)
# Left: filename
titleString = "JES: " + os.path.basename(self.fileName)
g.drawString(titleString, x, y)
# Center: text
pageNoString = "Page %d" % (pageIndex + 1)
pageNoWidth = g.getFontMetrics().stringWidth(pageNoString)
g.drawString(pageNoString, midX - (pageNoWidth / 2), y)
# Right: date
dateString = self.today
dateWidth = g.getFontMetrics().stringWidth(dateString)
g.drawString(dateString, maxX - dateWidth, y)
# Line below header
g.drawLine(minX, y + 6, maxX, y + 6)
# OK, now the text.
g.setColor(Color.black)
g.setFont(self.textFont)
# Generate as many lines as will fit in imageable area.
y += 24
while y + 12 < maxY:
line = self.raf.readLine()
if line is None:
# We've already printed the last line.
# Don't print another page.
self.pageAfterEnd = pageIndex + 1
return JESPrintable.PAGE_EXISTS
try:
g.drawString(line, x, y)
except:
# TBH I'm not sure what kind of exceptions happen here.
# (If the line's too long, it'll just print over the margin.)
# Unprintable characters maybe?
g.drawString(' ', x, y)
y = y + 12
if pageIndex + 1 == len(self.pagePointers):
# Hey, we've discovered the pointer to the next page!
# Let's add it to the list so the next print call works.
self.pagePointers.append(self.raf.getFilePointer())
return JESPrintable.PAGE_EXISTS
def get(self, index):
ra = None
try:
# Read cell origin and dimensions for cell at index
cellMin = zeros(3, 'l') # long[3]
cellDims = zeros(3, 'i') # integer[3]
grid.getCellDimensions(index, cellMin, cellDims)
# Unpack Cell origin (in pixel coordinates)
x, y, z = cellMin
# Unpack Cell dimensions: at margins, may be smaller than cell_width, cell_height
width, height, _ = cellDims # ignore depth: it's 1
# Read cell from file into a byte array
ra = RandomAccessFile(filepaths[z], 'r')
read_width = width * bytesPerPixel
bytes = zeros(read_width * height,
'b') # will contain the entire Cell pixel data
# Initial offset to the Cell origin
offset = (section_width * y + x) * bytesPerPixel
n_pixels = width * height
if width == section_width:
# Read whole block in one go: cell data is continuous in the file
ra.seek(offset)
ra.read(bytes, 0, n_pixels * bytesPerPixel)
else:
# Read line by line
n_read = 0
while n_read < n_pixels:
ra.seek(offset)
ra.read(bytes, n_read, read_width)
n_read += read_width # ensure n_read advances in case file is truncated to avoid infinite loop
offset += section_width * bytesPerPixel
# Create a new Cell of the right pixel type
return Cell(cellDims, cellMin, createAccess(bytes, bytesPerPixel))
except:
print sys.exc_info()
finally:
if ra:
ra.close()
try:
if not File(sys.getPath(filename)).createNewFile():
raise OSError(errno.EEXIST, errno.strerror(errno.EEXIST),
filename)
except java.io.IOException, ioe:
raise OSError(ioe)
mode = '%s%s%s%s' % (reading and 'r' or '',
(not appending and writing) and 'w' or '',
(appending and (writing or updating)) and 'a' or '',
updating and '+' or '')
if sync and (writing or updating):
from java.io import FileNotFoundException, RandomAccessFile
try:
fchannel = RandomAccessFile(sys.getPath(filename), 'rws').getChannel()
except FileNotFoundException, fnfe:
if path.isdir(filename):
raise OSError(errno.EISDIR, errno.strerror(errno.EISDIR))
raise OSError(errno.ENOENT, errno.strerror(errno.ENOENT), filename)
return FileIO(fchannel, mode)
return FileIO(filename, mode)
def read(fd, buffersize):
"""read(fd, buffersize) -> string
Read a file descriptor.
"""
from org.python.core.util import StringUtil
rawio = FileDescriptors.get(fd)
def readFIBSEMdat(path, channel_index=-1, header=1024, magic_number=3555587570, asImagePlus=False, toUnsigned=True):
""" Read a file from Shan Xu's FIBSEM software, where two or more channels are interleaved.
Assumes channels are stored in 16-bit.
path: the file path to the .dat file.
channel_index: the 0-based index of the channel to parse, or -1 (default) for all.
header: defaults to a length of 1024 bytes
magic_number: defaults to that for version 8 of Shan Xu's .dat image file format.
isSigned: defaults to True, will subtract the min value when negative.
asImagePlus: return a list of ImagePlus instead of ArrayImg which is the default.
"""
ra = RandomAccessFile(path, 'r')
try:
# Check the magic number
ra.seek(0)
magic = ra.readInt() & 0xffffffff
if magic != magic_number:
msg = "magic number mismatch: v8 magic " + str(magic_number) + " != " + str(magic) + " for path:\n" + path
System.out.println(msg)
print msg
# Continue: attempt to parse the file anyway
# Read the number of channels
ra.seek(32)
numChannels = ra.readByte() & 0xff # a single byte as unsigned integer
# Parse width and height
ra.seek(100)
width = ra.readInt()
ra.seek(104)
height = ra.readInt()
# Read the whole interleaved pixel array
ra.seek(header)
bytes = zeros(width * height * 2 * numChannels, 'b') # 2 for 16-bit
ra.read(bytes)
# Parse as 16-bit array
sb = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).asShortBuffer()
bytes = None
finally:
ra.close()
#
shorts = zeros(width * height * numChannels, 'h')
sb.get(shorts)
sb = None
# Deinterleave channels and convert to unsigned short
# Shockingly, these values are signed shorts, not unsigned! (for first popeye2 squid volume, December 2021)
# With ASM: fast
channels = DAT_handler.deinterleave(shorts, numChannels, channel_index)
shorts = None
#
if toUnsigned:
for s in channels:
DAT_handler.toUnsigned(s)
# With python array sampling: very slow, and not just from iterating whole array once per channel
#seq = xrange(numChannels) if -1 == channel_index else [channel_index]
#channels = [shorts[i::numChannels] for i in seq]
if asImagePlus:
return [ImagePlus(str(i), ShortProcessor(width, height, s, None)) for i, s in enumerate(channels)]
else:
return [ArrayImgs.unsignedShorts(s, [width, height]) for s in channels]
def savePointMatches(img_filename1,
img_filename2,
pointmatches,
directory,
params,
coords_header=["x1", "y1", "x2", "y2"]):
filename = basename(img_filename1) + '.' + basename(
img_filename2) + ".pointmatches.csv"
path = os.path.join(directory, filename)
msg = [str(len(pointmatches))]
ra = None
try:
"""
with open(path, 'w') as csvfile:
w = csv.writer(csvfile, delimiter=',', quotechar='"', quoting=csv.QUOTE_NONNUMERIC)
# First two rows: parameter names and values
keys = params.keys()
msg.append("keys: " + ",".join(map(str, keys)))
msg.append("vals: " + ",".join(str(params[key]) for key in keys))
#for pm in pointmatches:
# msg.append(", ".join(map(str, PointMatches.asRow(pm))))
w.writerow(keys)
w.writerow(tuple(params[key] for key in keys))
# PointMatches header
if 0 == len(pointmatches):
# Can't know whether there are 2 or 3 dimensions per coordinate
w.writerow(coords_header)
else:
w.writerow(PointMatches.csvHeader(next(iter(pointmatches)))) # support both lists and sets
# One PointMatch per row
for pm in pointmatches:
w.writerow(PointMatches.asRow(pm))
# Ensure it's written
csvfile.flush()
os.fsync(csvfile.fileno())
"""
# DEBUG write differently, the above FAILS for ~20 out of 130,000 files
lines = []
keys = params.keys()
lines.append(",".join(map(str, keys)))
lines.append(",".join(map(str, (params[key] for key in keys))))
header = coords_header if 0 == len(pointmatches) \
else PointMatches.csvHeader(next(iter(pointmatches)))
lines.append(",".join(header))
for pm in pointmatches:
p1 = pm.getP1().getW() # a double[] array
p2 = pm.getP2().getW() # a double[] array
lines.append("%f,%f,%f,%f" % (p1[0], p1[1], p2[0], p2[1]))
body = "\n".join(lines)
ra = RandomAccessFile(path, 'rw')
ra.writeBytes(body)
ra.getFD().sync() # ensure it's written
except:
syncPrintQ("Failed to save pointmatches at %s\n%s" %
(path, "\n".join(msg)))
printException()
if os.path.exists(path):
os.remove(path)
finally:
if ra is not None:
ra.close()
for z in xrange(img.dimension(2)):
radius = img.dimension(0) * 0.5 / (z + 1)
circle = GeomMasks.openSphere(center, radius)
# Works, explicit iteration of every pixel
#for t in Regions.sample(circle, Views.hyperSlice(img, 2, z)):
# t.setOne()
# Works: about twice as fast -- measured with: from time import time .... t0 = time(); ... t1 = time()
deque(imap(BitType.setOne,
Regions.sample(circle, Views.hyperSlice(img, 2, z))),
maxlen=0)
# Write as TIFF file
filepath = os.path.join(
tempfile.gettempdir(),
"bit-img-" + datetime.now().strftime("%Y-%m-%d-%H:%M:%S") + ".tif")
ra = RandomAccessFile(filepath, 'rw')
try:
# Header: big endian (4D, 4D) or (M, M), magic number (42, 42), and offset of 9 bytes to first IFD
# Note:
# bin(int("4D", 16))[2:].zfill(8) == '01001101'
# int("4D", 16) == 77
ra.write(array([77, 77, 0, 42, 0, 0, 0, 8], 'b'))
# A tmp plane img to copy into it each 2D slice for saving later as the pixel data of each IFD
plane_img = ArrayImgs.bits([img.dimension(0), img.dimension(1)])
plane_array = plane_img.update(None).getCurrentStorageArray() # a long[]
bb = ByteBuffer.allocate(len(plane_array) *
8) # each long primitive has 8 bytes
# Each IFD and image data
# Use either short (3) or int (4) for the DataType, so that ImageJ's ij.io.TiffDecoder can read it
tags = {
256: (4, 4, img.dimension(0)), # signed int (32-bit), 4 bytes, width
class JESPrintableDocument(JESPrintable):
def __init__(self, fileToPrint):
self.fileName = fileToPrint
self.today = SimpleDateFormat("yyyy.MM.dd HH:mm").format(Date())
self.textFont = Font("Monospaced", Font.PLAIN, 12)
# We use a RandomAccessFile because Java likes to seek around and
# print pages multiple times.
self.raf = RandomAccessFile(self.fileName, "r")
# These keep track of what pages we've found so far,
# and where in the file the pages start.
# Page 0's starts out filled, and the following pages' are filled
# at the end of its predecessor.
self.pagePointers = []
self.pageAfterEnd = None
# Set the pointer for page 0.
self.pagePointers.append(self.raf.getFilePointer())
def printPage(self, g, pform, pageIndex):
if pageIndex < len(self.pagePointers):
# We already know where this page starts. Seek there.
self.raf.seek(self.pagePointers[pageIndex])
elif pageIndex >= self.pageAfterEnd:
# We've found the end, and this page is after it.
return JESPrintable.NO_SUCH_PAGE
else:
# We haven't gotten here yet.
# Java will probably print each page multiple times,
# and maybe even repeat pages after their successors,
# but it should never print page n + 1 before page n.
raise RuntimeError("Printing pages out of order")
# Find our dimensions.
minX = int(pform.getImageableX() + 10)
width = int(pform.getImageableWidth() - 10)
maxX = int(minX + width)
midX = int(minX + width / 2)
minY = int(pform.getImageableY() + 12)
height = int(pform.getImageableHeight() - 12)
maxY = int(minY + height)
x, y = minX, minY
# Title lines
g.setColor(Color.black)
# Left: filename
titleString = "JES: " + os.path.basename(self.fileName)
g.drawString(titleString, x, y)
# Center: text
pageNoString = "Page %d" % (pageIndex + 1)
pageNoWidth = g.getFontMetrics().stringWidth(pageNoString)
g.drawString(pageNoString, midX - (pageNoWidth / 2), y)
# Right: date
dateString = self.today
dateWidth = g.getFontMetrics().stringWidth(dateString)
g.drawString(dateString, maxX - dateWidth, y)
# Line below header
g.drawLine(minX, y + 6, maxX, y + 6)
# OK, now the text.
g.setColor(Color.black)
g.setFont(self.textFont)
# Generate as many lines as will fit in imageable area.
y += 24
while y + 12 < maxY:
line = self.raf.readLine()
if line is None:
# We've already printed the last line.
# Don't print another page.
self.pageAfterEnd = pageIndex + 1
return JESPrintable.PAGE_EXISTS
try:
g.drawString(line, x, y)
except:
# TBH I'm not sure what kind of exceptions happen here.
# (If the line's too long, it'll just print over the margin.)
# Unprintable characters maybe?
g.drawString(' ', x, y)
y = y + 12
if pageIndex + 1 == len(self.pagePointers):
# Hey, we've discovered the pointer to the next page!
# Let's add it to the list so the next print call works.
self.pagePointers.append(self.raf.getFilePointer())
return JESPrintable.PAGE_EXISTS
