def write_metadata_xml(self, metadata_file):
ome_timestamp = self.acquisition_datetime()
xml_values = {
'image': {
'name': self.barcode(),
'acquisitionDate': ome_timestamp.isoformat(),
'description': self.derivation_description(),
'pixels': {
'sizeX': int(self.size_x),
'sizeY': int(self.size_y),
'physicalSizeX': self.pixel_size_x,
'physicalSizeY': self.pixel_size_y
}
},
'label': {
'pixels': {
'sizeX': int(self.label_x),
'sizeY': int(self.label_y)
}
},
'macro': {
'pixels': {
'sizeX': int(self.macro_x),
'sizeY': int(self.macro_y)
}
}
}
loader = PackageLoader()
template = loader.import_("isyntax2raw.resources.ome_template")
xml = template(xml_values).render()
with open(metadata_file, "w", encoding="utf-8") as omexml:
omexml.write(xml)
def render_kajiki(template=None, info=None, format=None, fragment=False, mapping=None):
global kajiki_loader
if kajiki_loader is None:
# Lazy imports of Kajiki
from kajiki import PackageLoader
kajiki_loader = PackageLoader()
Template = kajiki_loader.import_(template)
context = Bunch()
context.update(stdvars())
context.update(info)
templ = Template(context)
return templ.render()
def write_metadata(self):
'''write metadata to a JSON file'''
metadata_file = os.path.join(self.slide_directory, "METADATA.json")
with open(metadata_file, "w", encoding="utf-8") as f:
metadata = self.get_metadata()
for image in range(self.num_images()):
image_metadata = self.get_image_metadata(image)
metadata["Image #" + str(image)] = image_metadata
json.dump(metadata, f)
ome_timestamp = self.acquisition_datetime()
xml_values = {
'image': {
'name': self.barcode(),
'acquisitionDate': ome_timestamp.isoformat(),
'description': self.derivation_description(),
'pixels': {
'sizeX': int(self.size_x),
'sizeY': int(self.size_y),
'physicalSizeX': self.pixel_size_x,
'physicalSizeY': self.pixel_size_y
}
},
'label': {
'pixels': {
'sizeX': int(self.label_x),
'sizeY': int(self.label_y)
}
},
'macro': {
'pixels': {
'sizeX': int(self.macro_x),
'sizeY': int(self.macro_y)
}
}
}
loader = PackageLoader()
template = loader.import_("isyntax2raw.resources.ome_template")
xml = template(xml_values).render()
ome_xml_file = os.path.join(self.slide_directory, "METADATA.ome.xml")
with open(ome_xml_file, "w", encoding="utf-8") as omexml:
omexml.write(xml)
def render_kajiki(template=None,
info=None,
format=None,
fragment=False,
mapping=None):
global kajiki_loader
if kajiki_loader is None:
# Lazy imports of Kajiki
from kajiki import PackageLoader
kajiki_loader = PackageLoader()
Template = kajiki_loader.import_(template)
context = Bunch()
context.update(stdvars())
context.update(info)
templ = Template(context)
return templ.render()
def test_pkg_loader(self):
loader = PackageLoader()
loader.import_('kajiki.tests.data.debug')
def write_metadata(self):
'''write metadata to a JSON file'''
pe_in = self.pixel_engine["in"]
metadata_file = os.path.join(self.slide_directory, "METADATA.json")
with open(metadata_file, "w", encoding="utf-8") as f:
metadata = {
"Barcode": pe_in.BARCODE,
"DICOM acquisition date": pe_in.DICOM_ACQUISITION_DATETIME,
"DICOM last calibration date":
pe_in.DICOM_DATE_OF_LAST_CALIBRATION,
"DICOM time of last calibration":
pe_in.DICOM_TIME_OF_LAST_CALIBRATION,
"DICOM manufacturer": pe_in.DICOM_MANUFACTURER,
"DICOM manufacturer model name":
pe_in.DICOM_MANUFACTURERS_MODEL_NAME,
"DICOM device serial number": pe_in.DICOM_DEVICE_SERIAL_NUMBER,
"Color space transform": pe_in.colorspaceTransform(),
"Block size": pe_in.blockSize(),
"Number of tiles": pe_in.numTiles(),
"Bits stored": pe_in.bitsStored(),
"Derivation description": pe_in.DICOM_DERIVATION_DESCRIPTION,
"DICOM software version": pe_in.DICOM_SOFTWARE_VERSIONS,
"Number of images": pe_in.numImages()
}
size_x = 0
size_y = 0
label_x = 0
label_y = 0
macro_x = 0
macro_y = 0
pixel_size_x = 1.0
pixel_size_y = 1.0
for image in range(pe_in.numImages()):
img = pe_in[image]
image_metadata = {
"Image type": img.IMAGE_TYPE,
"DICOM lossy image compression method":
img.DICOM_LOSSY_IMAGE_COMPRESSION_METHOD,
"DICOM lossy image compression ratio":
img.DICOM_LOSSY_IMAGE_COMPRESSION_RATIO,
"DICOM derivation description":
img.DICOM_DERIVATION_DESCRIPTION,
"Image dimension names": img.IMAGE_DIMENSION_NAMES,
"Image dimension types": img.IMAGE_DIMENSION_TYPES,
"Image dimension units": img.IMAGE_DIMENSION_UNITS,
"Image dimension ranges": img.IMAGE_DIMENSION_RANGES,
"Image dimension discrete values":
img.IMAGE_DIMENSION_DISCRETE_VALUES_STRING,
"Image scale factor": img.IMAGE_SCALE_FACTOR
}
if img.IMAGE_TYPE == "WSI":
pixel_size_x = img.IMAGE_SCALE_FACTOR[0]
pixel_size_y = img.IMAGE_SCALE_FACTOR[1]
view = pe_in.SourceView()
image_metadata["Bits allocated"] = view.bitsAllocated()
image_metadata["Bits stored"] = view.bitsStored()
image_metadata["High bit"] = view.highBit()
image_metadata["Pixel representation"] = \
view.pixelRepresentation()
image_metadata["Planar configuration"] = \
view.planarConfiguration()
image_metadata["Samples per pixel"] = \
view.samplesPerPixel()
image_metadata["Number of levels"] = \
pe_in.numLevels()
for resolution in range(pe_in.numLevels()):
dim_ranges = view.dimensionRanges(resolution)
level_size_x = self.get_size(dim_ranges[0])
level_size_y = self.get_size(dim_ranges[1])
image_metadata["Level sizes #%s" % resolution] = {
"X": level_size_x,
"Y": level_size_y
}
if resolution == 0:
size_x = level_size_x
size_y = level_size_y
elif img.IMAGE_TYPE == "LABELIMAGE":
label_x = self.get_size(img.IMAGE_DIMENSION_RANGES[0]) + 1
label_y = self.get_size(img.IMAGE_DIMENSION_RANGES[1]) + 1
elif img.IMAGE_TYPE == "MACROIMAGE":
macro_x = self.get_size(img.IMAGE_DIMENSION_RANGES[0]) + 1
macro_y = self.get_size(img.IMAGE_DIMENSION_RANGES[1]) + 1
metadata["Image #" + str(image)] = image_metadata
json.dump(metadata, f)
timestamp = str(pe_in.DICOM_ACQUISITION_DATETIME)
ome_timestamp = datetime.strptime(timestamp, "%Y%m%d%H%M%S.%f")
xml_values = {
'image': {
'name': pe_in.BARCODE,
'acquisitionDate': ome_timestamp.isoformat(),
'description': pe_in.DICOM_DERIVATION_DESCRIPTION,
'pixels': {
'sizeX': int(size_x),
'sizeY': int(size_y),
'physicalSizeX': pixel_size_x,
'physicalSizeY': pixel_size_y
}
},
'label': {
'pixels': {
'sizeX': int(label_x),
'sizeY': int(label_y)
}
},
'macro': {
'pixels': {
'sizeX': int(macro_x),
'sizeY': int(macro_y)
}
}
}
loader = PackageLoader()
template = loader.import_("isyntax2raw.resources.ome_template")
xml = template(xml_values).render()
ome_xml_file = os.path.join(self.slide_directory, "METADATA.ome.xml")
with open(ome_xml_file, "w") as omexml:
omexml.write(xml)
def test_pkg_loader(self):
loader = PackageLoader()
loader.import_('kajiki.tests.data.debug')
def test_pkg_loader(self):
loader = PackageLoader()
loader.import_("kajiki_test_data.debug")
