def test_time_diff(self): """Post npz data with default channel""" p.args = (3000, 3100, 2000, 2100, 10, 11, 2, 3) image_data1 = np.ones([2, 1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data1, time=True) assert (response.status_code == 200) voxarray = getNPZ(p, time=True) # check that the return matches assert (np.array_equal(voxarray, image_data1)) p.args = (3000, 3100, 2000, 2100, 10, 11, 3, 4) image_data2 = np.ones([2, 1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data2, time=True) assert (response.status_code == 200) voxarray = getNPZ(p, time=True) # check that the return matches assert (np.array_equal(voxarray, image_data2)) p.args = (3000, 3100, 2000, 2100, 10, 11, 2, 4) url = "https://{}/sd/{}/{}/diff/{}/{},{}/{},{}/{},{}/{},{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution, *p.args) f = getURL(url) voxarray = blosc.unpack_array(f.content) image_data = np.subtract(np.float32(image_data1), np.float32(image_data2)) assert (np.array_equal(image_data[0, :], voxarray[0, :]))
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 32, 64, 9, 10) image_data = np.ones([1, 1, 32, 100, 100], dtype=np.uint8) * random.randint(0, 255) if KV_ENGINE == REDIS: response = postNPZ(p, image_data, time=True, direct=True) else: response = postNPZ(p, image_data, time=True) # Check if the project is not proagated f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) assert (value == NOT_PROPAGATED) # Start propagating f = getURL("https://{}/sd/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) # Checking if the PROPGATED value is set correctly for iter_value in range(1, 500, 1): time.sleep(1) f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) if value == PROPAGATED: break assert (value == PROPAGATED) # Checking at res1 p.args = (100, 150, 100, 150, 16, 32, 9, 10) p.resolution = 1 voxarray = getNPZ(p, time=True) assert (np.array_equal(voxarray[0][0][0], image_data[0][0][0][:50, :50])) # Checking at res2 p.args = (50, 75, 50, 75, 8, 16, 9, 10) p.resolution = 2 voxarray = getNPZ(p, time=True) assert (np.array_equal(voxarray[0][0][0], image_data[0][0][0][:25, :25])) # Checking at res3 p.args = (25, 37, 25, 37, 4, 8, 9, 10) p.resolution = 3 voxarray = getNPZ(p, time=True) assert (np.array_equal(voxarray[0][0][0], image_data[0][0][0][:12, :12]))
def test_npz_incorrect_channel (self): """Post npz data with incorrect channel""" p.channels = p.channels + ['IMAGE3'] image_data = np.ones ( [3,2,10,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data, time=True) assert (response.code == 404)
def test_npz_incorrect_region(self): """Post npz to incorrect region""" p.args = (11000, 11100, 4000, 4100, 500, 510) time_data = np.ones([2, 10, 100, 100], dtype=np.float32) * random.random() response = postNPZ(p, time_data)
def test_neuron(self): """Make a multiple segments that overlap and then query them as a neuron""" # create neuron makeAnno(p, 5) neuronid = p.annoid # create annotations for i in range(0, 3): # create annotations makeAnno(p, 4) f = setField(p, 'neuron', neuronid) # add data p.args = (3000, 3100, 4000, 4100, 100 + 2 * i, 100 + 2 * i + 3) image_data = np.ones([1, 3, 100, 100], dtype=np.uint32) * p.annoid response = postNPZ(p, image_data) # get the neuron annotation p.annoid = neuronid p.field = 'tight_cutout' h5ret = getAnnotation(p) idgrp = h5ret.get(str(p.annoid)) # count the voxels to make sure they remapped correctly assert (np.unique(np.array(idgrp['CUTOUT'][:, :, :])) == [0, neuronid ]).all() assert (len(np.nonzero(np.array( idgrp['CUTOUT'][:, :, :]))[0]) == 70000)
def setup_class(self): """Create the unittest database""" makeunitdb.createTestDB(p.token, p.channels, channel_type=IMAGE, channel_datatype=UINT8, public=True, ximagesize=1024, yimagesize=1024, zimagesize=20, xvoxelres=1.0, yvoxelres=1.0, zvoxelres=10.0, readonly=0) # modify params args to match new data size p.args = (0, 1024, 0, 1024, 1, 21) # post some sample image data self.image_data = np.random.randint(0, high=255, size=[1, 20, 1024, 1024]).astype(np.uint8) response = postNPZ(p, self.image_data) assert (response.code == 200) voxarray = getNPZ(p) # check that the return data matches assert (np.array_equal(voxarray, self.image_data))
def test_web_propagate(self): """Test the web update propogate function""" p.resolution = 0 # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 4, 5) image_data = np.ones([1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data) # check that it cannot post to a readonly channle assert (response.status_code == 404) # Check if the project is not proagated f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) assert (value == NOT_PROPAGATED) # check that it cannot start propagating a readonly channel assert (getURL("https://{}/sd/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)).status_code == 404) # check that it cannot mark a channel as propagated assert (getURL("https://{}/sd/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), PROPAGATED)).status_code == 404)
def test_neuron (self): """Make a multiple segments that overlap and then query them as a neuron""" # create neuron makeAnno(p,5) neuronid = p.annoid # create annotations for i in range(0,3): # create annotations makeAnno(p,4) f = setField(p,'neuron',neuronid) # add data p.args = (3000,3100,4000,4100,100+2*i,100+2*i+3) image_data = np.ones( [1,3,100,100], dtype=np.uint32 ) * p.annoid response = postNPZ(p, image_data) # get the neuron annotation p.annoid = neuronid p.field = 'tight_cutout' h5ret = getAnnotation(p) idgrp = h5ret.get(str(p.annoid)) # count the voxels to make sure they remapped correctly assert ( np.unique(np.array(idgrp['CUTOUT'][:,:,:])) == [0,neuronid] ).all() assert ( len(np.nonzero(np.array(idgrp['CUTOUT'][:,:,:]))[0]) == 70000 )
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200,300,200,300,4,5) image_data = np.ones( [1,1,100,100], dtype=np.uint8) * random.randint(0,255) response = postNPZ(p, image_data) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == NOT_PROPAGATED) # Start propagating f = getURL("http://{}/ca/{}/{}/setPropagate/{}/".format(SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) time.sleep(10) # Checking if the PROPGATED value is set correctly f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == PROPAGATED) # Checking at res1 p.args = (100,150,100,150,4,5) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution+1, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][0][:50,:50]) ) # Checking at res5 p.args = (7,9,7,9,4,5) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution+5, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][0][:2,:2]) )
def test_npz_incorrect_channel (self): """Post npz data with incorrect channel""" p.channels = p.channels + ['CHAN3'] image_data = np.ones ( [3,10,100,100], dtype=np.float32 ) * random.random() response = postNPZ(p, image_data) assert (response.code == 404)
def test_npz_incorrect_region (self): """Post npz to incorrect region""" p.args = (11000,11100,4000,4100,500,510) image_data = np.ones ( [2,10,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) assert (response.status_code == 404)
def test_get_anno_by_loc(self): """Test the annotation (RAMON) JSON interface""" image_data = np.random.randint(0, high=255, size=[1, 10, 1024, 1024]).astype(np.uint32) response = postNPZ(p, image_data) assert( response.status_code == 200 ) voxarray = getNPZ(p) # check that the return data matches assert( np.array_equal(voxarray, image_data) ) # query for an ID at res0 res = 0 x = 50 y = 50 z = 5 cutout = '{}/{}/{}/{}/'.format( res, x, y, z ) url = 'https://{}/sd/{}/{}/id/{}'.format( SITE_HOST, p.token, p.channels[0], cutout ) try: # Build a get request response = getURL(url) except Exception as e: print e assert( response.status_code == 200 ) response_id = int(response.content) # the offset for this dataset is set to 1, hence z-1 assert( response_id == image_data[0, z-1, y, x] )
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 4, 5) image_data = np.ones([1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert (value == PROPAGATED) # check that it cannot start propagating a channel which is already propagated assert (getURL("http://{}/ca/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) == 404) f = getURL("http://{}/ca/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), NOT_PROPAGATED)) # can set to not propagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert (value == NOT_PROPAGATED)
def test_npz_incorrect_channel (self): """Post npz data with incorrect channel""" p.channels = p.channels + ['IMAGE3'] image_data = np.ones ( [3,10,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) assert (response.code == 404)
def test_npz_incorrect_region(self): """Post npz to incorrect region""" p.args = (11000, 11100, 4000, 4100, 500, 510) image_data = np.ones([2, 10, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data)
def test_npz_incorrect_channel(self): """Post npz data with incorrect channel""" p.channels = p.channels + ['CHAN3'] time_data = np.ones([3, 10, 100, 100], dtype=np.float32) * random.random() response = postNPZ(p, time_data) assert (response.status_code == 404)
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 32, 64) p.resolution = 0 image_data = np.ones([1, 32, 100, 100], dtype=np.uint32) * random.randint(255, 65535) response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert (np.array_equal(voxarray, image_data)) # Check if the project is not proagated f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) assert (value == NOT_PROPAGATED) # Start propagating f = getURL("https://{}/sd/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) # Checking if the PROPGATED value is set correctly for iter_value in range(1, 100, 1): time.sleep(1) f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) if value == PROPAGATED: break assert (value == PROPAGATED) # Checking at res1 p.args = (100, 150, 100, 150, 16, 32) p.resolution = 1 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:50, :50])) # Checking at res2 p.args = (50, 75, 50, 75, 8, 16) p.resolution = 2 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:25, :25])) # Checking at res3 p.args = (25, 37, 25, 37, 4, 8) p.resolution = 3 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:12, :12])) # Checking at res4 p.args = (13, 19, 13, 19, 2, 4) p.resolution = 4 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:6, :6]))
def test_npz_incorrect_timesize (self): """Post npz data with incorrect time size""" p.args = (8000,9000,2000,3000,410,420,15,20) # upload some image data image_data = np.ones ( [2,7,10,100,100], dtype=np.uint16 ) * random.randint(0,255) response = postNPZ(p, image_data, time=True) assert (response.code == 404)
def test_get_blosc (self): """Test the xy slice cutout""" p.args = (3000,3100,4000,4100,200,201) image_data = np.ones( [2,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) posted_data = getBlosc(p) assert ( np.array_equal(image_data,posted_data) )
def test_get_raw(self): """Test the xyz cube cutout for raw data""" p.args = (3000, 3003, 4000, 4003, 200, 203, 50, 60) image_data = (np.random.rand(2, 10, 3, 3, 3) * 255).astype(np.uint8) response = postNPZ(p, image_data, time=True) requested_data = getRAW(p, time=True) requested_data.shape = (2, 10, 3, 3, 3) assert (np.array_equal(image_data, requested_data))
def test_npz_incorrect_datatype (self): """Post npz data with incorrect datatype""" p.args = (4000,4100,5000,5100,500,510) # upload some image data image_data = np.ones ( [2,10,100,100], dtype=np.float64 ) * random.random() response = postNPZ(p, image_data) assert (response.code == 404)
def test_npz_incorrect_datatype (self): """Post npz data with incorrect datatype""" p.args = (4000,4100,5000,5100,500,510,11,18) # upload some image data image_data = np.ones ( [2,7,10,100,100], dtype=np.uint16 ) * random.randint(0,255) response = postNPZ(p, image_data, time=True) assert (response.code == 404)
def test_genhistogram (self): """Test generating an 8bit histogram""" image_data = np.random.randint(0, high=255, size=[1, 10, 1024, 1024]).astype(np.uint8) response = postNPZ(p, image_data) assert( response.status_code == 200 ) voxarray = getNPZ(p) # check that the return data matches assert( np.array_equal(voxarray, image_data) ) # generate the histogram url = 'https://{}/stats/{}/{}/genhist/'.format( SITE_HOST, p.token, p.channels[0] ) try: # Build a get request response = getURL(url) except Exception as e: print e assert( response.status_code == 200 ) jsonresponse = json.loads(response.content) # make sure the celery job started celerystatus = celery_app.AsyncResult(jsonresponse['jobid']) # wait for histogram generation to finish (either 10 mins or failure) # note: actual generation time should be more like 0.2 seconds, but there may be other jobs in the queue count = 0 while celerystatus.state != 'SUCCESS': time.sleep(1) celerystatus = celery_app.AsyncResult(jsonresponse['jobid']) assert( celerystatus.state != 'FAILURE' ) assert( count != 60 ) count += 1 # now get the histogram url = 'https://{}/stats/{}/{}/hist/'.format( SITE_HOST, p.token, p.channels[0] ) try: # Build a get request response = getURL(url) except Exception as e: print e assert( response.status_code == 200 ) jsonresponse = json.loads(response.content) # now see if the two histograms are equivalent testhist = np.histogram(image_data[image_data > 0], bins=256, range=(0,256)) # check to see that the bins are equal assert( np.array_equal( jsonresponse['bins'], testhist[1] ) ) # check to see that the counts are equal assert( np.array_equal( jsonresponse['hist'], testhist[0] ) )
def test_get_direct_neariso_raw(self): """Test the xyz cube cutout direct for raw data""" p.args = (400, 403, 200, 203, 10, 15, 7, 9) image_data = (np.random.rand(2, 2, 5, 3, 3) * 255).astype(np.uint8) response = postNPZ(p, image_data, time=True, neariso=True, direct=True) requested_data = getRAW(p, time=True, neariso=True) requested_data.shape = (2, 2, 5, 3, 3) assert (np.array_equal(image_data, requested_data))
def test_get_blosc(self): """Test the xy slice cutout""" p.args = (3000, 3100, 4000, 4100, 200, 201) image_data = np.ones([2, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data) posted_data = getBlosc(p) assert (np.array_equal(image_data, posted_data))
def test_npz_default_channel (self): """Post npz data with default channel""" image_data = np.ones ( [1,10,100,100], dtype=np.uint8 ) * random.randint(0,255) p.channels = None response = postNPZ(p, image_data) assert (response.code == 200) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray,image_data) )
def test_npz_incorrect_datatype(self): """Post npz data with incorrect datatype""" p.args = (4000, 4100, 5000, 5100, 500, 510) # upload some image data time_data = np.ones([2, 10, 100, 100], dtype=np.float64) * random.random() response = postNPZ(p, time_data) assert (response.status_code == 404)
def test_npz_default_channel(self): """Post npz data with default channel""" image_data = np.ones([1, 10, 100, 100], dtype=np.uint8) * random.randint(0, 255) p.channels = None response = postNPZ(p, image_data) assert (response.code == 200) voxarray = getNPZ(p) # check that the return matches assert (np.array_equal(voxarray, image_data))
def test_xy (self): """Test the xy slice cutout""" p.args = (3000,3100,4000,4100,200,201) image_data = np.ones( [2,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) url = "https://{}/sd/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.content)) ) assert ( np.array_equal(slice_data,image_data[0][0]) )
def test_xy (self): """Test the xy slice cutout""" p.args = (3000,3100,4000,4100,200,201,10,12) time_data = np.ones( [2,2,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, time_data, time=True) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], p.args[6]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, time_data[0][0][0]) )
def test_xz (self): """Test the xz slice cutout""" p.args = (5000,5100,2000,2001,200,300) image_data = np.ones( [2,100,1,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/xz/{}/{},{}/{}/{},{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[4], p.args[5]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][:75][:].reshape(75,100)) )
def test_create_json(self): """Test the basic JSON project creation with only the required fields""" p.channels = ['CHAN1', 'CHAN2'] # dataset format = (dataset_name, [ximagesz, yimagesz, zimagesz], [[xvoxel, yvoxel, zvoxel], [xoffset, yoffset, zoffset], timerange, scalinglevels, scaling) dataset = (p.dataset, [2000, 2000, 1000], [1.0, 1.0, 5.0], None, None, None, None) # project format = (project_name, token_name, public) project = (p.token, None, None) # channel format = { chan1 : (channel_name, datatype, channel_type, data_url, file_name, exceptions, resolution, windowrange, readonly), chan2: ...... } channels = { p.channels[0]: (p.channels[0], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, 0), p.channels[1]: (p.channels[1], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, 0), } json_file = tempfile.NamedTemporaryFile(mode='w+b') json_file.write( createJson(dataset, project, channels, channel_only=True)) json_file.seek(0) # posting the JSON url and checking if it is successful response = json.loads( postURL( "http://{}/ca/{}/createChannel/".format(SITE_HOST, p.token), json_file).read()) assert ( 'SUCCESS. The information in the channel was correct.' == response) # fetching the JSON info f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the JSON file proj_info = json.loads(f.read()) assert (proj_info['project']['name'] == p.token) assert (proj_info['dataset']['imagesize']['0'] == [2000, 2000, 1000]) assert (proj_info['dataset']['cube_dimension']['0'] == [128, 128, 16]) assert (proj_info['dataset']['scalinglevels'] == 5) assert (proj_info['channels'][p.channels[0]]['resolution'] == 0) assert (proj_info['channels'][p.channels[0]]['channel_type'] == p.channel_type) assert (proj_info['channels'][p.channels[1]]['datatype'] == p.datatype) # Testing if the it allows data to be posted to the created channels p.args = (1000, 1100, 500, 600, 200, 201) image_data = np.ones([2, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data) voxarray = getNPZ(p) assert (np.array_equal(image_data, voxarray))
def test_get_direct_raw(self): """Test the xyz cube cutout direct for raw data""" p.args = (1000, 1003, 2000, 2003, 100, 103, 10, 12) # p.args = (512, 1024, 0, 512, 1, 65) image_data = (np.random.rand(2, 2, 3, 3, 3) * 255).astype(np.uint8) # image_data = (np.random.rand(2, 64, 512, 512) * 255).astype(np.uint8) response = postNPZ(p, image_data, time=True, direct=True) requested_data = getRAW(p, time=True) requested_data.shape = (2, 2, 3, 3, 3) # requested_data.shape = (2,64,512,512) assert (np.array_equal(image_data, requested_data))
def test_yz (self): """Test the yz slice cutout""" p.args = (4000,4001,3000,3100,200,300,10,11) image_data = np.ones( [2,1,100,100,1], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data, time=True) url = "http://{}/ca/{}/{}/yz/{}/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[2], p.args[3], p.args[4], p.args[5], p.args[6]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][0][:75][:].reshape(75,100)) )
def test_npz (self): """Post npz data to correct region with correct datatype""" p.args = (3000,3100,4000,4100,500,510,20,24) # upload some image data image_data = np.ones ( [2,4,10,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data, time=True) # Checking for successful post assert( response.code == 200 ) voxarray = getNPZ(p, time=True) # check that the return matches assert ( np.array_equal(voxarray,image_data) )
def test_npz (self): """Post npz data to correct region with correct datatype""" p.args = (3000,3100,4000,4100,500,510) # upload some image data image_data = np.ones ( [2,10,100,100], dtype=np.float32 ) * random.random() response = postNPZ(p, image_data) # Checking for successful post assert( response.code == 200 ) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray,image_data) )
def test_yz (self): """Test the yz slice cutout""" p.args = (4000,4001,3000,3100,200,300) image_data = np.ones( [2,100,100,1], dtype=np.float32 ) * random.random() response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/yz/{}/{}/{},{}/{},{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[2], p.args[3], p.args[4], p.args[5]) f = getURL (url) image_data = np.uint8(image_data*256) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data[:,:,0], image_data[0][:75][:].reshape(75,100)) )
def test_get_jpeg (self): """Test the jpeg volume cutout""" p.args = (3000,3100,4000,4100,200,210) image_data = np.ones( [2,10,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/jpeg/{}/{},{}/{},{}/{},{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], p.args[5]) data = getURL(url).read() posted_data = np.asarray( Image.open(cStringIO.StringIO(data)) ) image_data = image_data[0,:,:,:].reshape(1000,100) assert ( np.array_equal(image_data,posted_data) )
def test_window_default(self): "Test the window functionality" p.args = (3000,3100,4000,4100,200,201,50,52) image_data = np.ones([2,2,1,100,100], dtype=np.uint16) * 2000 response = postNPZ(p, image_data, time=True) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/{}".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], p.args[6]) f = getURL (url) from windowcutout import windowCutout windowCutout(image_data, p.window) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data,image_data[0][0][0]) )
def test_xy_tile(self): """Test a mcfc xy tile fetch""" p.args = (3072,3584,4096,4608,200,201) # have to use a constant here for memcache purposes image_data = np.ones([2,1,512,512], dtype=np.uint8) * 200 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray, image_data) ) url = "http://{}/catmaid/mcfc/{}/{}/xy/{}/{}_{}_{}.png".format(SITE_HOST, p.token, ','.join(p.channels), p.args[4], p.args[2]/512, p.args[0]/512, p.resolution) f = getURL (url)
def test_window_default(self): "Test the window functionality" p.args = (3000,3100,4000,4100,200,201) image_data = np.ones([2,1,100,100], dtype=np.uint16) * 2000 response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL (url) from windowcutout import windowCutout windowCutout(image_data, p.window) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data,image_data[0][0]) )
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200,300,200,300,32,64) p.resolution=0 image_data = np.ones( [1,32,100,100], dtype=np.uint32) * random.randint(255,65535) response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray,image_data) ) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == NOT_PROPAGATED) # Start propagating f = getURL("http://{}/ca/{}/{}/setPropagate/{}/".format(SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) # Checking if the PROPGATED value is set correctly time.sleep(30) f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == PROPAGATED) # Checking at res1 p.args = (100,150,100,150,16,32) p.resolution = 1 voxarray = getNPZ(p) assert ( np.array_equal(voxarray[0][0], image_data[0][0][:50,:50]) ) # Checking at res2 p.args = (50,75,50,75,8,16) p.resolution = 2 voxarray = getNPZ(p) assert ( np.array_equal(voxarray[0][0], image_data[0][0][:25,:25]) ) # Checking at res3 p.args = (25,37,25,37,4,8) p.resolution = 3 voxarray = getNPZ(p) assert ( np.array_equal(voxarray[0][0], image_data[0][0][:12,:12]) ) # Checking at res4 p.args = (13,19,13,19,2,4) p.resolution = 4 voxarray = getNPZ(p) assert ( np.array_equal(voxarray[0][0], image_data[0][0][:6,:6]) )
def test_npz(self): """Post npz data to correct region with correct datatype""" p.args = (3000, 3100, 4000, 4100, 500, 510) # upload some image data time_data = np.ones([2, 10, 100, 100], dtype=np.float32) * random.random() response = postNPZ(p, time_data) # Checking for successful post assert (response.status_code == 200) voxarray = getNPZ(p) # check that the return matches assert (np.array_equal(voxarray, time_data))
def test_window_args(self): "Test the window functionality" p.args = (3000,3100,4000,4100,200,201) p.window = [0,1500] image_data = np.ones([2,1,100,100], dtype=np.uint16) * 2000 response = postNPZ(p, image_data) url = "https://{}/sd/{}/{}/xy/{}/{},{}/{},{}/{}/window/{},{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], *p.window) f = getURL (url) from ndlib.windowcutout import windowCutout image_data = windowCutout(image_data, p.window).astype(np.uint8) slice_data = np.asarray ( Image.open(StringIO(f.content)) ) assert ( np.array_equal(slice_data,image_data[0][0]) )
def test_xz (self): """Test the xz slice cutout""" p.args = (5000,5100,2000,2001,200,300,10,12) time_data = np.ones( [2,2,100,1,100], dtype=np.float32 ) * random.random() response = postNPZ(p, time_data, time=True) url = "https://{}/sd/{}/{}/xz/{}/{},{}/{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[4], p.args[5], p.args[6]) f = getURL (url) from ndlib.windowcutout import windowCutout time_data = windowCutout(time_data, p.window).astype(np.uint8) # time_data = np.uint8(time_data*256) slice_data = np.asarray ( Image.open(StringIO(f.content)) ) assert ( np.array_equal(slice_data, time_data[0][0][:75][:].reshape(75,100)) )
def test_direct_neariso_npz(self): """Post npz data to correct region with correct datatype""" p.resolution = 2 p.args = (1000, 1100, 500, 600, 100, 110, 10, 14) # upload some image data image_data = np.ones([2, 4, 10, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data, time=True, neariso=True, direct=True) # Checking for successful post assert (response.status_code == 200) voxarray = getNPZ(p, time=True, neariso=True) # check that the return matches assert (np.array_equal(voxarray, image_data))
def test_xy_tile(self): """Test a mcfc xy tile fetch""" p.args = (3072, 3584, 4096, 4608, 200, 201) # have to use a constant here for memcache purposes image_data = np.ones([2, 1, 512, 512], dtype=np.uint8) * 200 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert (np.array_equal(voxarray, image_data)) url = "http://{}/catmaid/mcfc/{}/{}/xy/{}/{}_{}_{}.png".format( SITE_HOST, p.token, ','.join(p.channels), p.args[4], p.args[2] / 512, p.args[0] / 512, p.resolution) f = getURL(url)
def test_xy(self): """Test the xy slice cutout""" p.args = (3000, 3100, 4000, 4100, 200, 201) image_data = np.ones([2, 1, 100, 100], dtype=np.float32) * random.random() response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) image_data = np.uint8(image_data * 256) slice_data = np.asarray(Image.open(StringIO(f.read()))) assert (np.array_equal(slice_data[:, :, 0], image_data[0][0]))
def test_xy_default_channel (self): """Test the xy slice cutout""" p.args = (3000,3100,4000,4100,200,201) image_data = np.ones( [1,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) assert (response.code == 200) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray,image_data) ) url = "http://{}/ca/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data,image_data[0][0]) )
def test_xy_neariso_zoom_in(self): """Test the xy slice cutout""" p.resolution = 3 p.args = (1000, 1100, 500, 600, 10, 11, 10, 12) time_data = np.ones([2, 2, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, time_data, time=True, neariso=True, direct=False) assert (response.status_code == 200) p.resolution = 0 p.args = (8000, 8800, 4000, 4800, 30, 31, 10, 12) url = "https://{}/sd/{}/{}/xy/{}/{},{}/{},{}/{}/{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], p.args[6]) response = getURL(url)
def setup_class(self): """Create the unittest database""" makeunitdb.createTestDB(p.token, p.channels, channel_type=IMAGE, channel_datatype=UINT8, public=True, ximagesize=1024, yimagesize=1024, zimagesize=20, xvoxelres=1.0, yvoxelres=1.0, zvoxelres=10.0, readonly=0) # modify params args to match new data size p.args = (0,1024,0,1024,1,21) # post some sample image data self.image_data = np.random.randint(0, high=255, size=[1, 20, 1024, 1024]).astype(np.uint8) response = postNPZ(p, self.image_data) assert( response.code == 200 ) voxarray = getNPZ(p) # check that the return data matches assert( np.array_equal(voxarray, self.image_data) )
def test_xy_tile(self): """Test a simple xy tile fetch""" p.args = (1536,2048,4096,4608,200,201) # have to use a constant here for memcache purposes image_data = np.ones([2,1,512,512], dtype=np.uint8) * 130 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray, image_data) ) url = "http://{}/catmaid/viking/{}/volume/{}/{}/X{}_Y{}_Z{}.png".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0]/512, p.args[2]/512, p.args[4]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][0]) )
def test_xz_tile (self): """Test a simple xz slice fetch""" p.args = (3072,3584,4096,4097,1,513) # have to use a constant here for memcache purposes image_data = np.ones([2,512,1,512], dtype=np.uint8) * 130 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray, image_data) ) url = "http://{}/catmaid/{}/{}/xz/{}/{}_{}_{}.png".format(SITE_HOST, p.token, p.channels[0], p.args[4]/512, p.args[2], p.args[0]/512, p.resolution) f = getURL (url) scale_range = 512*p.voxel[2]/p.voxel[0] slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data[:scale_range,:], image_data[0,:scale_range,0,:]) )
def test_yz_tile (self): """Test a simple yz slice fetch""" p.args = (8072,8073,4096,4608,1,513) # have to use a constant here for memcache purposes image_data = np.ones([2,512,512,1], dtype=np.uint8) * 130 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray, image_data) ) # yz/x/z_y_res url = "https://{}/catmaid/{}/{}/yz/{}/{}_{}_{}.png".format(SITE_HOST, p.token, p.channels[0], p.args[0], p.args[4]/512, p.args[2]/512, p.resolution) f = getURL (url) scale_range = int(512*p.voxel[2]/p.voxel[1]) slice_data = np.asarray ( Image.open(StringIO(f.content)) ) assert ( np.array_equal(slice_data[:scale_range,:], image_data[0,:scale_range,:,0] ))
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200,300,200,300,4,5) image_data = np.ones( [1,1,100,100], dtype=np.uint8) * random.randint(0,255) response = postNPZ(p, image_data) # check that it cannot post to a readonly channle assert(response.code == 404) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == NOT_PROPAGATED) # check that it cannot start propagating a readonly channel assert (getURL("http://{}/ca/{}/{}/setPropagate/{}/".format(SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) == 404 ) # check that it cannot mark a channel as propagated assert (getURL("http://{}/ca/{}/{}/setPropagate/{}/".format(SITE_HOST, p.token, ','.join(p.channels), PROPAGATED)) == 404 )
def test_genhistogram (self): """Test generating an 8bit histogram""" image_data = np.random.randint(0, high=255, size=[1, 10, 1024, 1024]).astype(np.uint8) response = postNPZ(p, image_data) assert( response.code == 200 ) voxarray = getNPZ(p) # check that the return data matches assert( np.array_equal(voxarray, image_data) ) # generate the histogram url = 'http://{}/stats/{}/{}/genhist/'.format( SITE_HOST, p.token, p.channels[0] ) try: # Build a get request req = urllib2.Request(url) response = urllib2.urlopen(req) except urllib2.HTTPError,e: return e
def test_create_json(self): """Test the basic JSON project creation with only the required fields""" p.channels = ['CHAN1', 'CHAN2'] # dataset format = (dataset_name, [ximagesz, yimagesz, zimagesz], [[xvoxel, yvoxel, zvoxel], [xoffset, yoffset, zoffset], timerange, scalinglevels, scaling) dataset = (p.dataset, [2000,2000,1000], [1.0,1.0,5.0], None, None, None, None) # project format = (project_name, token_name, public) project = (p.token, None, None) # channel format = { chan1 : (channel_name, datatype, channel_type, data_url, file_name, exceptions, resolution, windowrange, readonly), chan2: ...... } channels = { p.channels[0] : (p.channels[0], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, 0), p.channels[1] : (p.channels[1], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, 0), } json_file = tempfile.NamedTemporaryFile(mode='w+b') json_file.write(createJson(dataset, project, channels, channel_only=True)) json_file.seek(0) # posting the JSON url and checking if it is successful response = json.loads(postURL("http://{}/ca/{}/createChannel/".format(SITE_HOST, p.token), json_file).read()) assert('SUCCESS. The information in the channel was correct.' == response) # fetching the JSON info f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the JSON file proj_info = json.loads(f.read()) assert( proj_info['project']['name'] == p.token ) assert( proj_info['dataset']['imagesize']['0'] == [2000,2000,1000]) assert( proj_info['dataset']['cube_dimension']['0'] == [128,128,16]) assert( proj_info['dataset']['scalinglevels'] == 5) assert( proj_info['channels'][p.channels[0]]['resolution'] == 0) assert( proj_info['channels'][p.channels[0]]['channel_type'] == p.channel_type) assert( proj_info['channels'][p.channels[1]]['datatype'] == p.datatype) # Testing if the it allows data to be posted to the created channels p.args = (1000,1100,500,600,200,201) image_data = np.ones( [2,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) voxarray = getNPZ(p) assert( np.array_equal(image_data, voxarray) )