def get_scaled_spec(source_spec):
w = source_spec.width
h = source_spec.height
factor = float(size) / max(float(w), float(h))
w *= factor
h *= factor
s = OpenImageIO.ImageSpec(int(w), int(h), 4, OpenImageIO.UINT8)
s.channelnames = ('R', 'G', 'B', 'A')
s.alpha_channel = 3
s.attribute('oiio:ColorSpace', 'sRGB')
s.attribute('oiio:Gamma', '0.454545')
return s
def test_tiff_cmyk():
# Create a file that has unassociated alpha
filename = "test_cmyk.tif"
print("Testing write and read of TIFF CMYK with auto RGB translation:")
spec = oiio.ImageSpec(2, 2, 4, "uint8")
spec.attribute("tiff:ColorSpace", "CMYK")
spec.channelnames = ("C", "M", "Y", "K")
wbuf = oiio.ImageBuf(spec)
oiio.ImageBufAlgo.fill(wbuf, (0.5, 0.0, 0.0, 0.5))
print(" writing: ", wbuf.get_pixels())
wbuf.write(filename)
rbuf = oiio.ImageBuf(filename)
print("\n default reading as IB: ", rbuf.get_pixels())
config = oiio.ImageSpec()
config.attribute("oiio:RawColor", 1)
rbuf = oiio.ImageBuf(filename, 0, 0, config)
print("\n reading as IB with rawcolor=1: ", rbuf.get_pixels())
print("\n reading as II with rawcolor=0, read scanlines backward: ")
ii = oiio.ImageInput.open(filename)
print(" [1] = ", ii.read_scanline(1))
print(" [0] = ", ii.read_scanline(0))
print("\n")
def writeTIFF16(filename, data, size=(8, 8), attributes={}):
w, h = size
spec = oiio.ImageSpec(w, h, 4, oiio.UINT16)
for key, val in attributes.items():
spec.attribute(key, val)
out = oiio.ImageOutput.create(filename)
assert out, "Can not create ImageOutput \"%s\"" % oiio.getError()
assert out.open(
filename, spec,
oiio.Create), "Can not open %s : \"%s\"" % (filename, oiio.getError())
out.write_image(spec.format, data)
out.close()
print filename
def decrypt():
import OpenImageIO as o
import array
import pickle
import random
path = raw_input("Enter OIIO plugin path: ")
key_path = raw_input("Name of the file with the key: ")
in_file = raw_input("Name of the encrypted file: ")
# Open the input files, read the RNG state and store it in "key"
f = open(key_path, "r")
key = pickle.load(f)
spec_cr = o.ImageSpec()
pic_cr = o.ImageInput.create(in_file, path)
pic_cr.open(in_file, spec_cr)
desc_cr = spec_cr.format
# The encrypted pixel values will be stored here.
# The decoding will be done inplace, so that will also be
# the output buffer once the decryption is done.
arr_cr = array.array("B", "\0" * spec_cr.image_bytes())
length = range(len(arr_cr))
print "Working, please wait..."
# Let's read the encrypted image
pic_cr.read_image(desc_cr, arr_cr)
# Set the state of the RNG to match the state of the RNG which coded
# the image. After this, we can generate the same random sequence
# used to code the image.
random.setstate(key)
# Decryption!
for i in length:
rand_val = random.randint(0, 255)
# This is the inverse of the encryption.
restored_pixel = arr_cr[i] - rand_val
if restored_pixel < 0:
arr_dec[i] = 256 + restored_pixel
else:
arr_dec[i] = restored_pixel
print "Decryption completed!"
image = raw_input("Enter the name under which to store the result: ")
print "Working, please wait..."
out_dec = o.ImageOutput.create(image, path)
out_dec.open(image, spec_cr, False)
out_dec.write_image(desc_cr, arr_dec)
out_dec.close()
return True
def make_test_pattern1 (filename, xres=288, yres=216) :
buf = oiio.ImageBuf (oiio.ImageSpec (xres, yres, 3, oiio.FLOAT))
for y in range(yres) :
for x in range(xres) :
b = 0.25 + 0.5 * float (((x/16) & 1) ^ ((y/16) & 1))
if x == 1 or y == 1 or x == xres-2 or y == yres-2 :
b = 0.0
if (((x >= 10 and x <= 20) or (x >= xres-20 and x <= xres-10)) and
((y >= 10 and y <= 20) or (y >= yres-20 and y <= yres-10))) :
b = 0.0
if ((x == 15 or x == xres-15) and (y == 15 or y == yres-15)) :
b = 1.0
buf.setpixel (x, y, (float(x)/1000.0, float(y)/1000.0, b))
buf.write (filename)
def ii_read_scanline_simple_test():
# This method reads to continuous float pixels.
# The wrapper is missing a check which would make sure that the opened image
# contains float pixels. The first test segfaults when it tries to read
# a wrong image.
print "Starting ImageInput::read_scanline() (overload) tests..."
pic_rss = oiio.ImageInput.create("../../../oiio-testimages/tahoe-gps.jpg", plugin_path)
if pic_rss == None:
print "Can't open test image, skipping read_scanline() (overload) tests"
print
return
spec_rss = oiio.ImageSpec()
pic_rss.open("../../../oiio-testimages/tahoe-gps.jpg", spec_rss)
arr_rss = array.array("B", "1234" * spec_rss.scanline_bytes()) # '1234' == sizeof(float)
# test 1
if (pic_rss.read_scanline(0, 0, arr_rss)):
print "Test 1 passed"
else:
print "Test 1 failed"
# test 1.1
# This test passes a buffer much larger than is actually needed.
arr_rss2 = array.array("B", "\0" * spec_rss.image_bytes())
if (pic_rss.read_scanline(0, 0, arr_rss2)):
print "Test 1.1 passed"
else:
print "Test 1.1 failed"
# test 2 (check if method returns False when given a non-existing scanline -1)
try:
pic_rss.read_scanline(-1, 0, arr_rss)
print "Test 2 failed"
except IndexError:
print "Test 2 passed"
# test 3
test3 = "failed"
a = "this is not a proper argument"
try:
pic_rss.read_scanline(a, 0, arr_rss)
except:
test3 = "passed"
print "Test 3", test3
# test 4 (a buffer of insufficient size is passed)
test4 = "failed"
arr_rss = array.array("B", "\0" * (spec_rss.scanline_bytes() -1))
try:
pic_rss.read_scanline(0, 0, arr_rss)
except IndexError:
test4 = "passed"
print "Test 4", test4
print
def test_stitch_thirds():
pic_third1 = "/home/dgaletic/code/oiio-testimages/stitch_me/tahoe-0.jpg"
pic_third2 = "/home/dgaletic/code/oiio-testimages/stitch_me/tahoe-1.jpg"
pic_third3 = "/home/dgaletic/code/oiio-testimages/stitch_me/tahoe-2.jpg"
path = "/home/dgaletic/code/oiio-trunk/dist/linux/lib"
spec1 = o.ImageSpec()
spec2 = o.ImageSpec()
spec3 = o.ImageSpec()
pic1 = o.ImageInput.create("jpg", path)
pic2 = o.ImageInput.create("jpg", path)
pic3 = o.ImageInput.create("jpg", path)
pic1.open(pic_third1, spec1)
pic2.open(pic_third2, spec2)
pic3.open(pic_third3, spec3)
spec_stitched = o.ImageSpec(spec1.width + spec2.width + spec3.width, spec1.height, spec1.nchannels, spec1.format)
# create a list of opened ImageInput instances
images = [pic1, pic2, pic3]
# stitch the images next to each other, return the resulting array
arr = stitch_row(images)
if arr:
out = o.ImageOutput.create("jpg", path)
out.open("/home/dgaletic/code/branch/src/python/thirds.jpg", spec_stitched, False)
out.write_image(spec_stitched.format, arr)
out.close()
def crypt():
import OpenImageIO as o
import array
import random
import pickle
path = raw_input("Enter OIIO plugin path: ")
in_file = raw_input("Enter the name of the file for encryption: ")
out_file = raw_input("Enter the name of the resulting file: ")
key_path = raw_input("Enter the name of the file in which to store the key: ")
# open the input file
spec = o.ImageSpec()
pic = o.ImageInput.create(in_file, path)
pic.open(in_file, spec)
desc = spec.format
# Create a couple of arrays where we'll store the data.
# They all need to be the same size, and we'll fill them with dummy data for now.
# We'll read the original pixel values in arr
arr = array.array("B", "\0" * spec.image_bytes())
# the values we'll write to the encrypted file
new_values = arr[:]
length = range(len(new_values))
print "Working, please wait..."
pic.read_image(desc, arr)
# save the state of the random number generator so we can use it
# to decode the image
state = random.getstate()
# generate random values, add them to the original values.
# Do % 256 so nothing overflows
for i in length:
rand_val = random.randint(0, 255)
new_values[i] = (arr[i] + rand_val) % 256
# write new values to the output file, close everything
out = o.ImageOutput.create(out_file, path)
out.open(out_file, spec, False)
out.write_image(desc, new_values)
out.close()
# save the state of the RNG - that's the key for decryption
f = open(key_path, "w")
pickle.dump(state, f)
f.close()
return True
def frame_thread(self):
stitch_args = None
try:
stitch_args = self.stitch_queue.get_nowait()
except queue.Empty:
pass
while stitch_args:
frame = stitch_args[0]
tiles_path = Path(stitch_args[1])
images_path = Path(stitch_args[2])
frame_path = str(os.path.join(images_path, frame["outfile"]))
print("Assembling frame {}".format(frame_path))
first_tile_path = os.path.join(tiles_path,
frame["tiles"][0]["outfile"])
if os.path.isfile(first_tile_path):
first_tile = oiio.ImageBuf(str(first_tile_path))
spec = first_tile.spec()
frame_buf = oiio.ImageBuf(
oiio.ImageSpec(frame["res_x"], frame["res_y"],
spec.nchannels, spec.format))
for tile in frame["tiles"]:
tile_path = os.path.join(tiles_path, tile["outfile"])
if not os.path.isfile(tile_path):
continue
tile_buf = oiio.ImageBuf(str(tile_path))
oiio.ImageBufAlgo.paste(frame_buf, tile["coords"][0],
tile["coords"][1], 0, 0, tile_buf)
print("Writing {}".format(frame_path))
try:
os.mkdir(os.path.dirname(frame_path))
except FileExistsError:
pass
frame_buf.write(str(frame_path))
else:
print("Could not find first tile. Aborting frame stitch")
try:
stitch_args = self.stitch_queue.get_nowait()
except queue.Empty:
print("Worker exiting")
break
def generate_1d_LUT_image(ramp_1d_path,
resolution=1024,
min_value=0,
max_value=1):
"""
Generates a 1D LUT image, i.e. a simple ramp, going from the min_value to
the max_value.
Parameters
----------
ramp_1d_path : str or unicode
The path of the 1D ramp image to be written
resolution : int, optional
The resolution of the 1D ramp image to be written
min_value : float, optional
The lowest value in the 1D ramp
max_value : float, optional
The highest value in the 1D ramp
Returns
-------
None
"""
ramp = oiio.ImageOutput.create(ramp_1d_path)
spec = oiio.ImageSpec()
spec.set_format(oiio.FLOAT)
# spec.format.basetype = oiio.FLOAT
spec.width = resolution
spec.height = 1
spec.nchannels = 3
ramp.open(ramp_1d_path, spec, oiio.Create)
data = array.array('f',
'\0' * spec.width * spec.height * spec.nchannels * 4)
for i in range(resolution):
value = float(i) / (resolution - 1) * (
max_value - min_value) + min_value
data[i * spec.nchannels + 0] = value
data[i * spec.nchannels + 1] = value
data[i * spec.nchannels + 2] = value
ramp.write_image(spec.format, data)
ramp.close()
def ii_read_native_scanline_test():
print "Starting ImageInput::read_native_scanline() tests..."
pic_rns = oiio.ImageInput.create("../../../oiio-images/tahoe-gps.jpg",
plugin_path)
if pic_rns == None:
print "Can't open test image, skipping read_native_scanline() tests"
print
return
spec_rns = oiio.ImageSpec()
pic_rns.open("../../../oiio-images/tahoe-gps.jpg", spec_rns)
arr_rns = array.array("B", "\0" * spec_rns.scanline_bytes())
# test 1
if (pic_rns.read_native_scanline(0, 0, arr_rns)):
print "Test 1 passed"
else:
print "Test 1 failed"
# test 1.1
# This test passes a buffer much larger than is actually needed.
arr_rns2 = array.array("B", "\0" * spec_rns.image_bytes())
if (pic_rns.read_native_scanline(0, 0, arr_rns2)):
print "Test 1.1 passed"
else:
print "Test 1.1 failed"
# test 2 (check if method returns False when given a non-existing scanline -1)
if (not pic_rns.read_native_scanline(-1, 0, arr_rns)):
print "Test 2 passed"
else:
print "Test 2 failed"
# test 3
test3 = "failed"
a = "this is not a proper argument"
try:
pic_rns.read_native_scanline(a, 0, arr_rns)
except:
test3 = "passed"
print "Test 3", test3
# test 4 (a buffer of insufficient size is passed)
test4 = "failed"
arr_rns = array.array("B", "\0" * (spec_rns.scanline_bytes() - 1))
try:
pic_rns.read_native_scanline(0, 0, arr_rns)
except IndexError:
test4 = "passed"
print "Test 4", test4
print
def is_image_pixels_test():
print "Starting ImageSpec::image_pixels tests..."
spec = oiio.ImageSpec()
# test 1
if spec.image_pixels() == 0:
print "Test 1 passed"
else:
print "Test 1 failed"
# test 2 (call with wrong() argument)
a = "not a proper argument"
try:
spec.image_pixels(a)
print "Test 2 failed"
except:
print "Test 2 passed"
print
def is_scanline_bytes_test():
print "Starting ImageSpec::scanline_bytes tests..."
spec = oiio.ImageSpec()
# test 1
if spec.scanline_bytes() == 0:
print "Test 1 passed"
else:
print "Test 1 failed"
# test 2 (call with wrong argument)
a = "not a proper argument"
try:
spec.scanline_bytes(a)
print "Test 2 failed"
except:
print "Test 2 passed"
print
def oiio_get_buf(source, hash=None, force=False):
"""Check and load a source image with OpenImageIO's format reader.
Args:
source (str): Path to an OpenImageIO compatible image file.
hash (str): Specify the hash manually, otherwise will be generated.
force (bool): When `true`, forces the buffer to be re-cached.
Returns:
ImageBuf: An `ImageBuf` instance or `None` if the image cannot be read.
"""
common.check_type(source, str)
if hash is None:
hash = common.get_hash(source)
if not force and ImageCache.contains(hash, BufferType):
return ImageCache.value(hash, BufferType)
# We use the extension to initiate an ImageInput with a format
# which in turn is used to check the source's validity
if '.' not in source:
return None
ext = source.split('.').pop().lower()
if ext not in get_oiio_extensions():
return None
i = OpenImageIO.ImageInput.create(ext)
if not i or not i.valid_file(source):
i.close()
return None
# If all went well, we can initiate an ImageBuf
config = OpenImageIO.ImageSpec()
config.format = OpenImageIO.TypeDesc(OpenImageIO.FLOAT)
buf = OpenImageIO.ImageBuf()
buf.reset(source, 0, 0, config=config)
if buf.has_error:
print(buf.geterror())
return None
ImageCache.setValue(hash, buf, BufferType)
return buf
def tiles_from_heatmap(frame, depth, threshold, heatmap_dir):
# Load rendered heatmap
frame_path = os.path.join(heatmap_dir, frame["outfile"])
print("Frame path: {}".format(frame_path))
frame_buf = oiio.ImageBuf(str(os.path.join(heatmap_dir, frame["outfile"])))
orig_spec = oiio.ImageSpec(frame_buf.spec())
orig_spec.width = frame["res_x"]
orig_spec.full_width = frame["res_x"]
orig_spec.height = frame["res_y"]
orig_spec.full_height = frame["res_y"]
resized_frame_buf = oiio.ImageBuf(orig_spec)
oiio.ImageBufAlgo.resize(resized_frame_buf, frame_buf)
# Create tiles from resized images
quadtree = QuadSplit(Rect(0, resized_frame_buf.spec().width, 0, resized_frame_buf.spec().height), 1, depth, ["raycount"], threshold)
quadtree.test_image(resized_frame_buf)
return quadtree.get_quads()
def test_deep():
# Test write and read of deep data
# Let's try writing one
print("\nWriting deep buffer...")
deepbufout_spec = oiio.ImageSpec(2, 2, 5, oiio.FLOAT)
deepbufout_spec.channelnames = ("R", "G", "B", "A", "Z")
deepbufout_spec.deep = True
deepbufout = oiio.ImageBuf(deepbufout_spec)
deepbufout.set_deep_samples(x=1, y=0, z=0, nsamples=2)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=0, sample=0, value=0.42)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=4, sample=0, value=42.0)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=0, sample=1, value=0.47)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=4, sample=1, value=43.0)
# Also insert some new samples
deepbufout.deep_insert_samples(x=1, y=0, z=0, samplepos=1, nsamples=2)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=0, sample=1, value=1.1)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=1, sample=1, value=2.2)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=2, sample=1, value=2.3)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=3, sample=1, value=1.0)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=3, sample=1, value=42.25)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=0, sample=2, value=0.1)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=1, sample=2, value=0.2)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=2, sample=2, value=0.3)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=3, sample=2, value=1.0)
deepbufout.set_deep_value(x=1, y=0, z=0, channel=3, sample=2, value=42.5)
# But delete the first one
deepbufout.deep_erase_samples(x=1, y=0, z=0, samplepos=1, nsamples=1)
# Save
deepbufout.write("deepbuf.exr")
# And read it back
print("\nReading back deep buffer:")
deepbufin = oiio.ImageBuf("deepbuf.exr")
deepbufin_spec = deepbufin.spec()
dd = deepbufin.deepdata()
for p in range(dd.pixels):
ns = dd.samples(p)
if ns > 1:
print("Pixel", p // deepbufin_spec.width, p % deepbufin_spec.width,
"had", ns, "samples")
for s in range(ns):
print("Sample", s)
for c in range(dd.channels):
print("\tc {0} : {1:.3f}".format(c, dd.deep_value(p, c,
s)))
def _create_mipmap(self, source_path, target_path):
"""
Use OIIO to convert a given image into a mipmapped image.
:param source_path: path to source image file
:param target_path: path to write the mipmapped file to
:return: bool (success of mipmap creation)
"""
# cast here as OIIO has an issue with unicode strings (C++ matches types strictly)
source_path = str(source_path)
target_path = str(target_path)
_img_input = oiio.ImageBuf(source_path)
_target_spec = oiio.ImageSpec(_img_input.spec())
_target_spec.attribute("maketx:filtername", "lanczos3")
_target_spec.attribute("maketx:fixnan", "box3")
return oiio.ImageBufAlgo.make_texture(oiio.MakeTxTexture, _img_input,
target_path, _target_spec)
def test_multiimage():
print("Writing multi-image file")
spec = oiio.ImageSpec(128, 64, 3, "float")
out = oiio.ImageOutput.create("multipart.exr")
# Open with intent to write two subimages, each with same spec
if not out.open("multipart.exr", (spec, spec)):
print("Error on initial open:", out.geterror())
return
img = oiio.ImageBufAlgo.fill((0.5, 0.0, 0.0), spec.roi)
if not img.write(out):
print("Error on write:", img.geterror())
return
if not out.open("multipart.exr", spec, "AppendSubimage"):
print("Error on open for append:", out.geterror())
return
img = oiio.ImageBufAlgo.fill((0.0, 0.5, 0.0), spec.roi)
if not img.write(out):
print("Error on write:", img.geterror())
return
out.close()
def write_image_cubemap(cubemap, filename):
output = oiio.ImageOutput.create(filename)
mode = oiio.Create
size = cubemap[0].shape[0]
# print "size {}".format(cubemap[0].shape[0])
spec_rgba = oiio.ImageSpec(size, size, 3, oiio.FLOAT)
for face in cubemap:
output.open(filename, spec_rgba, mode)
# can't transform to rgb
s = face.shape[0]
# delete the A from RGBA
f = face.view(dtype=numpy.float32).reshape(s * s, 4)
f = numpy.delete(f, 3, 1)
buffer = numpy.getbuffer(f)
output.write_image(oiio.FLOAT, buffer)
mode = oiio.AppendSubimage
output.close()
def save_image(filename, image):
ext = get_path_ext(filename).lower()
if ext == 'pfm':
save_pfm(filename, image)
else:
output = oiio.ImageOutput.create(filename)
if not output:
raise RuntimeError('could not create image: "' + filename + '"')
format = oiio.FLOAT if ext == 'exr' else oiio.UINT8
spec = oiio.ImageSpec(image.shape[1], image.shape[0], image.shape[2], format)
if ext == 'exr':
spec.attribute('compression', 'piz')
elif ext == 'png':
spec.attribute('png:compressionLevel', 3)
if not output.open(filename, spec):
raise RuntimeError('could not open image: "' + filename + '"')
# FIXME: copy is needed for arrays owned by PyTorch for some reason
if not output.write_image(image.copy()):
raise RuntimeError('could not save image')
output.close()
def run_io_tests():
# first we use ImageInput to produce data ImageOutput uses
spec = oiio.ImageSpec()
inp = oiio.ImageInput.create("../../../oiio-images/tahoe-gps.jpg",
plugin_path)
inp.open("../../../oiio-images/tahoe-gps.jpg", spec)
desc = spec.format
arr = array.array("B", "\0" * spec.image_bytes(True))
inp.read_image(desc, arr)
io_create_test()
io_spec_test()
io_open_test(spec)
io_close_test(spec)
io_write_image_test(arr, spec) # lengthy operation
io_copy_image_test(inp, spec)
io_format_name_test(spec)
io_supports_test(spec)
io_error_message_test(spec)
io_write_scanline_test()
def is_default_channel_names_test():
print "Starting ImageSpec::default_channel_names() tests..."
spec = oiio.ImageSpec()
# test 1
test1 = "passed"
try:
spec.default_channel_names()
assert spec.channelnames == ()
except:
test1 = "failed"
print "Test 1", test1
# test 2
a = "not a proper argument"
test2 = "failed"
try:
spec.default_channel_names_test(a)
except:
test2 = "passed (wrong argument raised exception)"
print
def maketx():
Input = oiio.ImageBuf(
"/s/prodanim/ta/assets/Character/huHuman/surface_texturing/surface_texturing/work/textures/testAces/huHuman_longSleevesShirt_smooth_1001_BaseColor.exr"
)
config = oiio.ImageSpec()
config.set_format(oiio.HALF)
oiio.ImageBufAlgo.colorconvert(Input, Input, 'linear_srgb',
'Utility - sRGB - Texture')
config.attribute("maketx:highlightcomp", 1)
config.attribute("maketx:filtername", "lanczos3")
config.attribute("maketx:opaque_detect", 1)
config.attribute('maketx:forcefloat', 1)
config.attribute('maketx:fileformatname', 'tx')
config.attribute('maketx:incolorspace', 'srgb8')
config.attribute('maketx:outcolorspace', 'acescg')
Input.set_write_format(oiio.HALF)
ok = oiio.ImageBufAlgo.make_texture(
oiio.MakeTxTexture, Input,
"/s/prodanim/ta/_sandbox/duda/tmp/crap/acescg_testC.tx", config)
if not ok:
print("error:", oiio.geterror())
def io_write_scanline_test():
print "Running ImageInput::write_scanline() tests..."
# create II instance and open a file
spec_ws = oiio.ImageSpec()
pic_ws = oiio.ImageInput.create("../../../oiio-testimages/tahoe-gps.jpg",
plugin_path)
pic_ws.open("../../../oiio-testimages/tahoe-gps.jpg", spec_ws)
#create IO instance and open a file for writing
out_ws = oiio.ImageOutput.create(
"../../../oiio-testimages/tahoe-gps-scanline.jpg", plugin_path)
out_ws.open("../../../oiio-testimages/tahoe-gps-scanline.jpg", spec_ws,
False)
desc_ws = spec_ws.format
# test 1 (reads each scanline and writes it to a new file)
# this tests several things, so it's quite good if it passed
try:
for i in range(spec_ws.height):
arr_ws = array.array("B", "\0" * spec_ws.scanline_bytes())
pic_ws.read_scanline(i, 0, desc_ws, arr_ws)
out_ws.write_scanline(i, 0, desc_ws, arr_ws)
print "Test 1 passed"
except:
print "Test 1 failed (raised exception)"
out_ws.close()
# test 2 (same as test 1, but will pass a nonexisting coordinate)
try:
for i in range(spec_ws.height):
arr_ws = array.array("B", "\0" * spec_ws.scanline_bytes())
pic_ws.read_scanline(i, 0, desc_ws, arr_ws)
out_ws.write_scanline(i, 0, desc_ws, arr_ws)
print "Test 1 passed"
except:
print "Test 1 failed (raised exception)"
out_ws.close()
print
def is_attribute_test():
print "Running ImageSpec::attribute tests..."
spec = oiio.ImageSpec()
# test 1
try:
spec.attribute("test_attribute_int", 1)
print "Test 1 passed"
except:
print "Test 1 failed (exception raised)"
# test 2
try:
spec.attribute("test_attribute_float", 3.14)
print "Test 2 passed"
except:
print "Test 2 failed (exception raised)"
# test 3
try:
spec.attribute("test_attribute_string", "asd")
print "Test 3 passed"
except:
print "Test 3 failed (exception raised)"
# test 4
try:
spec.attribute("test_attribute_int", "a")
print "Test 4 passed"
except:
print "Test 4 failed (exception raised)"
# test 5 (wrong argument passed)
a = ["not a proper argument"]
try:
spec.attribute(a, 1)
print "Test 5 failed (accepted wrong argument)"
except:
print "Test 5 passed"
print
def is_format_from_quantize_test():
print "Starting ImageSpec::format_from_quantize tests..."
spec = oiio.ImageSpec()
#test 1 (calls without the class instance)
try:
desc = oiio.ImageSpec.format_from_quantize(0, 255, 0, 255)
print "Test 1 passed"
except:
print "Test 1 failed"
# test 2 (calls from instance)
try:
desc = spec.format_from_quantize(0, 255, 0, 255)
print "Test 2 passed"
except:
print "Test 2 failed"
# test 3 (call with wrong arguments)
a = "not a proper argument"
try:
desc = spec.format_from_quantize(a)
print "Test 3 failed (accepts wrong arguments)"
except:
print "Test 3 passed"
print
def write (image, filename, format=oiio.UNKNOWN) :
if not image.has_error :
image.write (filename, format)
if image.has_error :
print ("Error writing", filename, ":", image.geterror())
######################################################################
# main test starts here
try:
print ("Constructing to be a writeable 320x240,4 UINT16:")
b = oiio.ImageBuf (oiio.ImageSpec(320,240,4,oiio.UINT16))
print_imagespec (b.spec())
print ("Resetting to be a writeable 640x480,3 Float:")
b.reset (oiio.ImageSpec(640,480,3,oiio.FLOAT))
print_imagespec (b.spec())
print ("")
# Test reading from disk
print ("Testing read of ../common/textures/grid.tx:")
b = oiio.ImageBuf ("../common/textures/grid.tx")
print ("subimage:", b.subimage, " / ", b.nsubimages)
print ("miplevel:", b.miplevel, " / ", b.nmiplevels)
print ("channels:", b.nchannels)
print ("name:", b.name)
print ("file_format_name:", b.file_format_name)
print ("deep:", b.deep)
# test readtile
print("Testing read_tile:")
test_readtile("grid.tx")
# test readscanlines
print("Testing read_scanlines:")
test_readimage(OIIO_TESTSUITE_IMAGEDIR + "/tahoe-gps.jpg",
method="scanlines")
# test readtiles
print("Testing read_tiles:")
test_readimage("grid.tx", method="tiles")
# test reading a raw buffer in native format, we should get back
# an unsigned byte array.
b = oiio.ImageBuf(oiio.ImageSpec(64, 64, 3, oiio.UINT16))
oiio.ImageBufAlgo.fill(b, (1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1))
write(b, "testu16.tif", oiio.UINT16)
b.set_write_tiles(32, 32)
write(b, "testf16.exr", oiio.HALF)
print("Test read_image native u16:")
test_readimage("testu16.tif",
method="image",
type=oiio.UNKNOWN,
keep_unknown=True,
print_pixels=False)
print("Test read_scanlines native u16:")
test_readimage("testu16.tif",
method="scanlines",
type=oiio.UNKNOWN,
keep_unknown=True,
for i in range(len(spec.extra_attribs)):
if type(spec.extra_attribs[i].value) == str:
print " ", spec.extra_attribs[
i].name, "= \"" + spec.extra_attribs[i].value + "\""
else:
print " ", spec.extra_attribs[i].name, "=", spec.extra_attribs[
i].value
######################################################################
# main test starts here
try:
print "Constructing to be a writeable 320x240,4 UINT16:"
b = oiio.ImageBuf(oiio.ImageSpec(320, 240, 4, oiio.UINT16))
print_imagespec(b.spec())
print "Resetting to be a writeable 640x480,3 Float:"
b.reset(oiio.ImageSpec(640, 480, 3, oiio.FLOAT))
print_imagespec(b.spec())
print ""
# Test reading from disk
print "Testing read of grid.tx:"
b = oiio.ImageBuf("../common/textures/grid.tx")
print "subimage:", b.subimage, " / ", b.nsubimages
print "miplevel:", b.miplevel, " / ", b.nmiplevels
print "channels:", b.nchannels
print "name:", b.name
print "file_format_name:", b.file_format_name
print "deep:", b.deep
def is_data_members_test():
print "Starting tests of various ImageSpec data members..."
spec = oiio.ImageSpec()
# test 1
if spec.height != 0:
print "Test 1 failed"
else:
print "Test 1 passed"
# test 2
if spec.width != 0:
print "Test 2 failed"
else:
print "Test 2 passed"
# test 3
if spec.x != 0:
print "Test 3 failed"
else:
print "Test 3 passed"
# test 4
if spec.y != 0:
print "Test 4 failed"
else:
print "Test 4 passed"
# test 5
if spec.z != 0:
print "Test 5 failed"
else:
print "Test 5 passed"
# test 6
if spec.full_x != 0:
print "Test 6 failed"
else:
print "Test 6 passed"
# test 7
if spec.full_y != 0:
print "Test 7 failed"
else:
print "Test 7 passed"
# test 8
if spec.full_z != 0:
print "Test 8 failed"
else:
print "Test 8 passed"
# test 9
if spec.full_width != 0:
print "Test 9 failed"
else:
print "Test 9 passed"
# test 10
if spec.full_height != 0:
print "Test 10 failed"
else:
print "Test 10 passed"
# test 11
if spec.full_depth != 0:
print "Test 11 failed"
else:
print "Test 11 passed"
# test 12
if spec.tile_width != 0:
print "Test 12 failed"
else:
print "Test 12 passed"
# test 13
if spec.tile_height != 0:
print "Test 13 failed"
else:
print "Test 13 passed"
# test 14
if spec.tile_depth != 1:
print "Test 14 failed"
else:
print "Test 14 passed"
# test 15
if spec.alpha_channel != -1:
print "Test 15 failed"
else:
print "Test 15 passed"
# test 16
if spec.z_channel != -1:
print "Test 16 failed"
else:
print "Test 16 passed"
# test 17
if spec.gamma != 1.0:
print "Test 17 failed"
else:
print "Test 17 passed"
# test 18
if spec.quant_black != 0:
print "Test 18 failed"
else:
print "Test 18 passed"
# test 19
if spec.quant_white != 255:
print "Test 19 failed"
else:
print "Test 19 passed"
# test 20
if spec.quant_min != 0:
print "Test 20 failed"
else:
print "Test 20 passed"
# test 21
if spec.quant_max != 255:
print "Test 22 failed"
else:
print "Test 21 passed"
# test 23
if spec.nchannels != 0:
print "Test 23 failed"
else:
print "Test 23 passed"
# test 24
test24 = ""
try:
assert spec.channelnames == ()
spec.channelnames = ('c', 'm', 'y', 'k')
assert spec.channelnames == ('c', 'm', 'y', 'k')
test24 = "passed"
except:
test24 = "failed"
print "Test 24", test24
print
