From c7010e0822c808ba9e490d9c3f30829c3ee68eb9 Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Mon, 11 Jan 2021 15:35:42 +0530 Subject: [PATCH 01/24] Update README.md --- README.md | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 70e2a1d9a..e3bceb82b 100644 --- a/README.md +++ b/README.md @@ -12,16 +12,20 @@ This is an unofficial inplementation of [VoxelNet: End-to-End Learning for Point # Installation 1. Clone this repository. -2. Compile the Cython module +2. Install the necessary packages +```bash +$ cat packages.txt | xargs sudo apt-get install +``` +3. Compile the Cython module ```bash $ python3 setup.py build_ext --inplace ``` -3. Compile the evaluation code +4. Compile the evaluation code ```bash $ cd kitti_eval $ g++ -o evaluate_object_3d_offline evaluate_object_3d_offline.cpp ``` -4. grant the execution permission to evaluation script +5. grant the execution permission to evaluation script ```bash $ cd kitti_eval $ chmod +x launch_test.sh From fbb2c1005b5bc022c6cc97c7ffbbf859748d1102 Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Mon, 11 Jan 2021 15:38:29 +0530 Subject: [PATCH 02/24] Add files via upload --- packages.txt | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 packages.txt diff --git a/packages.txt b/packages.txt new file mode 100644 index 000000000..ac1b52748 --- /dev/null +++ b/packages.txt @@ -0,0 +1,2 @@ +libboost-all-dev +python-numpy \ No newline at end of file From f8ab4eca049001b87a57540d13467175d1dbd507 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Mon, 11 Jan 2021 18:02:59 +0530 Subject: [PATCH 03/24] Update crop.py -> Changed import statement for imread. -> Updated directories -> Changed the output_name initialisation statement to actually write-over the existing file --- data/crop.py | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/data/crop.py b/data/crop.py index de5327e0f..805e7a1d6 100644 --- a/data/crop.py +++ b/data/crop.py @@ -1,6 +1,7 @@ import numpy as np -from scipy.misc import imread - +import PIL +from imageio import imread +#from scipy.misc.pilutil import imread CAM = 2 def load_velodyne_points(filename): @@ -50,7 +51,7 @@ def project_velo_points_in_img(pts3d, T_cam_velo, Rrect, Prect): def align_img_and_pc(img_dir, pc_dir, calib_dir): - + img = imread(img_dir) pts = load_velodyne_points( pc_dir ) P, Tr_velo_to_cam, R_cam_to_rect = load_calib(calib_dir) @@ -79,9 +80,9 @@ def align_img_and_pc(img_dir, pc_dir, calib_dir): return points # update the following directories -IMG_ROOT = '/media/hdc/KITTI/image/training/image_2/' -PC_ROOT = '/media/hdc/KITTI/point_cloud/raw_bin_files/training/velodyne/' -CALIB_ROOT = '/media/hdc/KITTI/calib/data_object_calib/training/calib/' +IMG_ROOT = "D:\VoxelNet-tensorflow\data_object_image_2\\training\image_2\\" +PC_ROOT = "D:\VoxelNet-tensorflow\data_object_velodyne\\training\\velodyne\\" +CALIB_ROOT = "D:\VoxelNet-tensorflow\data_object_calib\\training\calib\\" @@ -91,12 +92,8 @@ def align_img_and_pc(img_dir, pc_dir, calib_dir): calib_dir = CALIB_ROOT + '%06d.txt' % frame points = align_img_and_pc(img_dir, pc_dir, calib_dir) - - output_name = PC_ROOT + frame + '.bin' - points[:,:4].astype('float32').tofile(output_name) - - - - - + #output_name = PC_ROOT + str(frame) + '.bin' + output_name = PC_ROOT + str('%06d' % frame) + '.bin' + print(frame) + points[:,:4].astype('float32').tofile(output_name) From e824dc197531f4afa954c9bb79dad58524b029cf Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Tue, 12 Jan 2021 13:36:27 +0530 Subject: [PATCH 04/24] Update README.md --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index e3bceb82b..4d700019d 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,8 @@ This is an unofficial inplementation of [VoxelNet: End-to-End Learning for Point 1. Clone this repository. 2. Install the necessary packages ```bash -$ cat packages.txt | xargs sudo apt-get install +$ sudo apt-get install libboost-all-dev +$ sudo apt-get install python-numpy ``` 3. Compile the Cython module ```bash From 2a9ea6667d98f8af0a8610e97a136c5f38ad1507 Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Tue, 12 Jan 2021 13:37:20 +0530 Subject: [PATCH 05/24] Delete packages.txt --- packages.txt | 2 -- 1 file changed, 2 deletions(-) delete mode 100644 packages.txt diff --git a/packages.txt b/packages.txt deleted file mode 100644 index ac1b52748..000000000 --- a/packages.txt +++ /dev/null @@ -1,2 +0,0 @@ -libboost-all-dev -python-numpy \ No newline at end of file From 07ed648b2b6f230e1f4c78f1d15a21bfb9c2f477 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 12 Jan 2021 17:33:11 +0530 Subject: [PATCH 06/24] Update train.py changed tf.app.run(main) to tf.compat.v1.app.run(main) as app.run has been shifted in v2 --- train.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/train.py b/train.py index 441966f4b..06f8a2d60 100644 --- a/train.py +++ b/train.py @@ -197,4 +197,5 @@ def main(_): if __name__ == '__main__': - tf.app.run(main) + #tf.app.run(main) + tf.compat.v1.app.run(main) From a1204d92fda30b8d06c481f00fa227401275c118 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 12 Jan 2021 17:48:06 +0530 Subject: [PATCH 07/24] Update train.py made compatible with tf version 1 by replacing tf. with tf.compat.v1. wherever possible --- train.py | 51 ++++++++++++++++++++++++++++----------------------- 1 file changed, 28 insertions(+), 23 deletions(-) diff --git a/train.py b/train.py index 06f8a2d60..004fb54c4 100644 --- a/train.py +++ b/train.py @@ -8,6 +8,8 @@ import time import sys import tensorflow as tf +#import tensorflow.compat.v1 as tf + from itertools import count from config import cfg @@ -55,17 +57,20 @@ def main(_): start_epoch = 0 global_counter = 0 - gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=cfg.GPU_MEMORY_FRACTION, + #gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=cfg.GPU_MEMORY_FRACTION, + # visible_device_list=cfg.GPU_AVAILABLE, + # allow_growth=True) + gpu_options = tf.compat.v1.GPUOptions(per_process_gpu_memory_fraction=cfg.GPU_MEMORY_FRACTION, visible_device_list=cfg.GPU_AVAILABLE, allow_growth=True) - config = tf.ConfigProto( + config = tf.compat.v1.ConfigProto( gpu_options=gpu_options, device_count={ "GPU": cfg.GPU_USE_COUNT, }, allow_soft_placement=True, ) - with tf.Session(config=config) as sess: + with tf.compat.v1.Session(config=config) as sess: model = RPN3D( cls=cfg.DETECT_OBJ, single_batch_size=args.single_batch_size, @@ -99,55 +104,55 @@ def main(_): counter = 0 batch_time = time.time() for batch in iterate_data(train_dir, shuffle=True, aug=True, is_testset=False, batch_size=args.single_batch_size * cfg.GPU_USE_COUNT, multi_gpu_sum=cfg.GPU_USE_COUNT): - + counter += 1 global_counter += 1 - + if counter % summary_interval == 0: is_summary = True else: is_summary = False - + start_time = time.time() ret = model.train_step( sess, batch, train=True, summary = is_summary ) forward_time = time.time() - start_time batch_time = time.time() - batch_time - + print('train: {} @ epoch:{}/{} loss: {:.4f} reg_loss: {:.4f} cls_loss: {:.4f} cls_pos_loss: {:.4f} cls_neg_loss: {:.4f} forward time: {:.4f} batch time: {:.4f}'.format(counter,epoch, args.max_epoch, ret[0], ret[1], ret[2], ret[3], ret[4], forward_time, batch_time)) with open('log/train.txt', 'a') as f: f.write( 'train: {} @ epoch:{}/{} loss: {:.4f} reg_loss: {:.4f} cls_loss: {:.4f} cls_pos_loss: {:.4f} cls_neg_loss: {:.4f} forward time: {:.4f} batch time: {:.4f} \n'.format(counter, epoch, args.max_epoch, ret[0], ret[1], ret[2], ret[3], ret[4], forward_time, batch_time) ) - + #print(counter, summary_interval, counter % summary_interval) if counter % summary_interval == 0: print("summary_interval now") summary_writer.add_summary(ret[-1], global_counter) - + #print(counter, summary_val_interval, counter % summary_val_interval) if counter % summary_val_interval == 0: print("summary_val_interval now") batch = sample_test_data(val_dir, args.single_batch_size * cfg.GPU_USE_COUNT, multi_gpu_sum=cfg.GPU_USE_COUNT) - + ret = model.validate_step(sess, batch, summary=True) summary_writer.add_summary(ret[-1], global_counter) - + try: ret = model.predict_step(sess, batch, summary=True) summary_writer.add_summary(ret[-1], global_counter) except: print("prediction skipped due to error") - + if check_if_should_pause(args.tag): model.saver.save(sess, os.path.join(save_model_dir, 'checkpoint'), global_step=model.global_step) print('pause and save model @ {} steps:{}'.format(save_model_dir, model.global_step.eval())) sys.exit(0) - + batch_time = time.time() - + sess.run(model.epoch_add_op) - + model.saver.save(sess, os.path.join(save_model_dir, 'checkpoint'), global_step=model.global_step) - + # dump test data every 10 epochs if ( epoch + 1 ) % 10 == 0: # create output folder @@ -155,14 +160,14 @@ def main(_): os.makedirs(os.path.join(args.output_path, str(epoch), 'data'), exist_ok=True) if args.vis: os.makedirs(os.path.join(args.output_path, str(epoch), 'vis'), exist_ok=True) - + for batch in iterate_data(val_dir, shuffle=False, aug=False, is_testset=False, batch_size=args.single_batch_size * cfg.GPU_USE_COUNT, multi_gpu_sum=cfg.GPU_USE_COUNT): - + if args.vis: tags, results, front_images, bird_views, heatmaps = model.predict_step(sess, batch, summary=False, vis=True) else: tags, results = model.predict_step(sess, batch, summary=False, vis=False) - + for tag, result in zip(tags, results): of_path = os.path.join(args.output_path, str(epoch), 'data', tag + '.txt') with open(of_path, 'w+') as f: @@ -179,18 +184,18 @@ def main(_): cv2.imwrite( front_img_path, front_image ) cv2.imwrite( bird_view_path, bird_view ) cv2.imwrite( heatmap_path, heatmap ) - + # execute evaluation code cmd_1 = "./kitti_eval/launch_test.sh" cmd_2 = os.path.join( args.output_path, str(epoch) ) cmd_3 = os.path.join( args.output_path, str(epoch), 'log' ) os.system( " ".join( [cmd_1, cmd_2, cmd_3] ) ) - - + + print('train done. total epoch:{} iter:{}'.format( epoch, model.global_step.eval())) - + # finallly save model model.saver.save(sess, os.path.join( save_model_dir, 'checkpoint'), global_step=model.global_step) From e4686d3c5152e7b82fac278f972455d2f7fc315d Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 12 Jan 2021 17:49:49 +0530 Subject: [PATCH 08/24] Update model.py made compatible with tf.version 1 --- model/model.py | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/model/model.py b/model/model.py index 4cbe075b2..86aacb8ca 100644 --- a/model/model.py +++ b/model/model.py @@ -38,11 +38,11 @@ def __init__(self, boundaries = [80, 120] values = [ self.learning_rate, self.learning_rate * 0.1, self.learning_rate * 0.01 ] - lr = tf.train.piecewise_constant(self.epoch, boundaries, values) + lr = tf.compat.v1.train.piecewise_constant(self.epoch, boundaries, values) # build graph # input placeholders - self.is_train = tf.placeholder(tf.bool, name='phase') + self.is_train = tf.compat.v1.placeholder(tf.bool, name='phase') self.vox_feature = [] self.vox_number = [] @@ -56,10 +56,10 @@ def __init__(self, self.delta_output = [] self.prob_output = [] - self.opt = tf.train.AdamOptimizer(lr) + self.opt = tf.compat.v1.train.AdamOptimizer(lr) self.gradient_norm = [] self.tower_grads = [] - with tf.variable_scope(tf.get_variable_scope()): + with tf.compat.v1.variable_scope(tf.compat.v1.get_variable_scope()): for idx, dev in enumerate(self.avail_gpus): with tf.device('/gpu:{}'.format(dev)), tf.name_scope('gpu_{}'.format(dev)): # must use name scope here since we do not want to create new variables @@ -320,18 +320,18 @@ def predict_step(self, session, data, summary=False, vis=False): # only summry 1 in a batch cur_tag = tag[0] P, Tr, R = load_calib( os.path.join( cfg.CALIB_DIR, cur_tag + '.txt' ) ) - + front_image = draw_lidar_box3d_on_image(img[0], ret_box3d[0], ret_score[0], batch_gt_boxes3d[0], P2=P, T_VELO_2_CAM=Tr, R_RECT_0=R) - + bird_view = lidar_to_bird_view_img( lidar[0], factor=cfg.BV_LOG_FACTOR) - + bird_view = draw_lidar_box3d_on_birdview(bird_view, ret_box3d[0], ret_score[0], batch_gt_boxes3d[0], factor=cfg.BV_LOG_FACTOR, P2=P, T_VELO_2_CAM=Tr, R_RECT_0=R) - + heatmap = colorize(probs[0, ...], cfg.BV_LOG_FACTOR) - + ret_summary = session.run(self.predict_summary, { self.rgb: front_image[np.newaxis, ...], self.bv: bird_view[np.newaxis, ...], @@ -339,28 +339,28 @@ def predict_step(self, session, data, summary=False, vis=False): }) return tag, ret_box3d_score, ret_summary - + if vis: front_images, bird_views, heatmaps = [], [], [] for i in range(len(img)): cur_tag = tag[i] P, Tr, R = load_calib( os.path.join( cfg.CALIB_DIR, cur_tag + '.txt' ) ) - + front_image = draw_lidar_box3d_on_image(img[i], ret_box3d[i], ret_score[i], batch_gt_boxes3d[i], P2=P, T_VELO_2_CAM=Tr, R_RECT_0=R) - + bird_view = lidar_to_bird_view_img( lidar[i], factor=cfg.BV_LOG_FACTOR) - + bird_view = draw_lidar_box3d_on_birdview(bird_view, ret_box3d[i], ret_score[i], batch_gt_boxes3d[i], factor=cfg.BV_LOG_FACTOR, P2=P, T_VELO_2_CAM=Tr, R_RECT_0=R) - + heatmap = colorize(probs[i, ...], cfg.BV_LOG_FACTOR) - + front_images.append(front_image) bird_views.append(bird_view) heatmaps.append(heatmap) - + return tag, ret_box3d_score, front_images, bird_views, heatmaps return tag, ret_box3d_score @@ -394,5 +394,3 @@ def average_gradients(tower_grads): if __name__ == '__main__': pass - - From 3cee667a1168b9312825c01c2c87a1f97cde20cf Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 12 Jan 2021 17:50:43 +0530 Subject: [PATCH 09/24] Update group_pointcloud.py made compatible with tf.version1 --- model/group_pointcloud.py | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/model/group_pointcloud.py b/model/group_pointcloud.py index ef68fad8c..048df2658 100644 --- a/model/group_pointcloud.py +++ b/model/group_pointcloud.py @@ -14,11 +14,11 @@ class VFELayer(object): def __init__(self, out_channels, name): super(VFELayer, self).__init__() self.units = int(out_channels / 2) - with tf.variable_scope(name, reuse=tf.AUTO_REUSE) as scope: - self.dense = tf.layers.Dense( - self.units, tf.nn.relu, name='dense', _reuse=tf.AUTO_REUSE, _scope=scope) - self.batch_norm = tf.layers.BatchNormalization( - name='batch_norm', fused=True, _reuse=tf.AUTO_REUSE, _scope=scope) + with tf.compat.v1.variable_scope(name, reuse=tf.compat.v1.AUTO_REUSE) as scope: + self.dense = tf.compat.v1.layers.Dense( + self.units, tf.compat.v1.nn.relu, name='dense', _reuse=tf.compat.v1.AUTO_REUSE, _scope=scope) + self.batch_norm = tf.compat.v1.layers.BatchNormalization( + name='batch_norm', fused=True, _reuse=tf.compat.v1.AUTO_REUSE, _scope=scope) def apply(self, inputs, mask, training): # [K, T, 7] tensordot [7, units] = [K, T, units] @@ -49,30 +49,28 @@ def __init__(self, training, batch_size, name=''): # scalar self.batch_size = batch_size # [ΣK, 35/45, 7] - self.feature = tf.placeholder( + self.feature = tf.compat.v1.placeholder( tf.float32, [None, cfg.VOXEL_POINT_COUNT, 7], name='feature') # [ΣK] - self.number = tf.placeholder(tf.int64, [None], name='number') + self.number = tf.compat.v1.compat.v1.placeholder(tf.int64, [None], name='number') # [ΣK, 4], each row stores (batch, d, h, w) - self.coordinate = tf.placeholder( + self.coordinate = tf.compat.v1.placeholder( tf.int64, [None, 4], name='coordinate') - with tf.variable_scope(name, reuse=tf.AUTO_REUSE) as scope: + with tf.compat.v1.variable_scope(name, reuse=tf.compat.v1.AUTO_REUSE) as scope: self.vfe1 = VFELayer(32, 'VFE-1') self.vfe2 = VFELayer(128, 'VFE-2') # boolean mask [K, T, 2 * units] - mask = tf.not_equal(tf.reduce_max( + mask = tf.compat.v1.not_equal(tf.reduce_max( self.feature, axis=2, keep_dims=True), 0) x = self.vfe1.apply(self.feature, mask, self.training) x = self.vfe2.apply(x, mask, self.training) # [ΣK, 128] - voxelwise = tf.reduce_max(x, axis=1) + voxelwise = tf.compat.v1.reduce_max(x, axis=1) # car: [N * 10 * 400 * 352 * 128] # pedestrian/cyclist: [N * 10 * 200 * 240 * 128] - self.outputs = tf.scatter_nd( + self.outputs = tf.compat.v1.scatter_nd( self.coordinate, voxelwise, [self.batch_size, 10, cfg.INPUT_HEIGHT, cfg.INPUT_WIDTH, 128]) - - From 75cb6e59609fbe114a87921cd30bd9bd923f6ce6 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 12 Jan 2021 18:14:09 +0530 Subject: [PATCH 10/24] Update group_pointcloud.py changed kip_dims to keepdims in line 66 --- model/group_pointcloud.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/model/group_pointcloud.py b/model/group_pointcloud.py index 048df2658..884dbf4e7 100644 --- a/model/group_pointcloud.py +++ b/model/group_pointcloud.py @@ -63,7 +63,7 @@ def __init__(self, training, batch_size, name=''): # boolean mask [K, T, 2 * units] mask = tf.compat.v1.not_equal(tf.reduce_max( - self.feature, axis=2, keep_dims=True), 0) + self.feature, axis=2, keepdims=True), 0) x = self.vfe1.apply(self.feature, mask, self.training) x = self.vfe2.apply(x, mask, self.training) From 4cad17c6f843189217bc8424b7b37ec2bd9d546b Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 12 Jan 2021 19:20:56 +0530 Subject: [PATCH 11/24] Update rpn.py made compatible with tf v1 --- model/rpn.py | 52 ++++++++++++++++++++++++++-------------------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/model/rpn.py b/model/rpn.py index 365fcde4d..5ea30c0a7 100644 --- a/model/rpn.py +++ b/model/rpn.py @@ -17,20 +17,20 @@ def __init__(self, input, alpha=1.5, beta=1, sigma=3, training=True, name=''): self.input = input self.training = training # groundtruth(target) - each anchor box, represent as △x, △y, △z, △l, △w, △h, rotation - self.targets = tf.placeholder( + self.targets = tf.compat.v1.placeholder( tf.float32, [None, cfg.FEATURE_HEIGHT, cfg.FEATURE_WIDTH, 14]) # postive anchors equal to one and others equal to zero(2 anchors in 1 position) - self.pos_equal_one = tf.placeholder( + self.pos_equal_one = tf.compat.v1.placeholder( tf.float32, [None, cfg.FEATURE_HEIGHT, cfg.FEATURE_WIDTH, 2]) - self.pos_equal_one_sum = tf.placeholder(tf.float32, [None, 1, 1, 1]) - self.pos_equal_one_for_reg = tf.placeholder( + self.pos_equal_one_sum = tf.compat.v1.placeholder(tf.float32, [None, 1, 1, 1]) + self.pos_equal_one_for_reg = tf.compat.v1.placeholder( tf.float32, [None, cfg.FEATURE_HEIGHT, cfg.FEATURE_WIDTH, 14]) # negative anchors equal to one and others equal to zero - self.neg_equal_one = tf.placeholder( + self.neg_equal_one = tf.compat.v1.placeholder( tf.float32, [None, cfg.FEATURE_HEIGHT, cfg.FEATURE_WIDTH, 2]) - self.neg_equal_one_sum = tf.placeholder(tf.float32, [None, 1, 1, 1]) + self.neg_equal_one_sum = tf.compat.v1.placeholder(tf.float32, [None, 1, 1, 1]) - with tf.variable_scope('MiddleAndRPN_' + name): + with tf.compat.v1.variable_scope('MiddleAndRPN_' + name): # convolutinal middle layers temp_conv = ConvMD(3, 128, 64, 3, (2, 1, 1), (1, 1, 1), self.input, name='conv1') @@ -100,9 +100,9 @@ def __init__(self, input, alpha=1.5, beta=1, sigma=3, training=True, name=''): #self.p_pos = tf.nn.softmax(p_map, dim=3) self.output_shape = [cfg.FEATURE_HEIGHT, cfg.FEATURE_WIDTH] - self.cls_pos_loss = (-self.pos_equal_one * tf.log(self.p_pos + small_addon_for_BCE)) / self.pos_equal_one_sum - self.cls_neg_loss = (-self.neg_equal_one * tf.log(1 - self.p_pos + small_addon_for_BCE)) / self.neg_equal_one_sum - + self.cls_pos_loss = (-self.pos_equal_one * tf.compat.v1.log(self.p_pos + small_addon_for_BCE)) / self.pos_equal_one_sum + self.cls_neg_loss = (-self.neg_equal_one * tf.compat.v1.log(1 - self.p_pos + small_addon_for_BCE)) / self.neg_equal_one_sum + self.cls_loss = tf.reduce_sum( alpha * self.cls_pos_loss + beta * self.cls_neg_loss ) self.cls_pos_loss_rec = tf.reduce_sum( self.cls_pos_loss ) self.cls_neg_loss_rec = tf.reduce_sum( self.cls_neg_loss ) @@ -135,22 +135,22 @@ def smooth_l1(deltas, targets, sigma=3.0): def ConvMD(M, Cin, Cout, k, s, p, input, training=True, activation=True, bn=True, name='conv'): temp_p = np.array(p) temp_p = np.lib.pad(temp_p, (1, 1), 'constant', constant_values=(0, 0)) - with tf.variable_scope(name) as scope: + with tf.compat.v1.variable_scope(name) as scope: if(M == 2): paddings = (np.array(temp_p)).repeat(2).reshape(4, 2) pad = tf.pad(input, paddings, "CONSTANT") - temp_conv = tf.layers.conv2d( - pad, Cout, k, strides=s, padding="valid", reuse=tf.AUTO_REUSE, name=scope) + temp_conv = tf.compat.v1.layers.conv2d( + pad, Cout, k, strides=s, padding="valid", reuse=tf.compat.v1.AUTO_REUSE, name=scope) if(M == 3): paddings = (np.array(temp_p)).repeat(2).reshape(5, 2) - pad = tf.pad(input, paddings, "CONSTANT") - temp_conv = tf.layers.conv3d( - pad, Cout, k, strides=s, padding="valid", reuse=tf.AUTO_REUSE, name=scope) + pad = tf.compat.v1.pad(input, paddings, "CONSTANT") + temp_conv = tf.compat.v1.layers.conv3d( + pad, Cout, k, strides=s, padding="valid", reuse=tf.compat.v1.AUTO_REUSE, name=scope) if bn: - temp_conv = tf.layers.batch_normalization( - temp_conv, axis=-1, fused=True, training=training, reuse=tf.AUTO_REUSE, name=scope) + temp_conv = tf.compat.v1.layers.batch_normalization( + temp_conv, axis=-1, fused=True, training=training, reuse=tf.compat.v1.AUTO_REUSE, name=scope) if activation: - return tf.nn.relu(temp_conv) + return tf.compat.v1.nn.relu(temp_conv) else: return temp_conv @@ -158,14 +158,14 @@ def Deconv2D(Cin, Cout, k, s, p, input, training=True, bn=True, name='deconv'): temp_p = np.array(p) temp_p = np.lib.pad(temp_p, (1, 1), 'constant', constant_values=(0, 0)) paddings = (np.array(temp_p)).repeat(2).reshape(4, 2) - pad = tf.pad(input, paddings, "CONSTANT") - with tf.variable_scope(name) as scope: - temp_conv = tf.layers.conv2d_transpose( - pad, Cout, k, strides=s, padding="SAME", reuse=tf.AUTO_REUSE, name=scope) + pad = tf.compat.v1.pad(input, paddings, "CONSTANT") + with tf.compat.v1.variable_scope(name) as scope: + temp_conv = tf.compat.v1.layers.conv2d_transpose( + pad, Cout, k, strides=s, padding="SAME", reuse=tf.compat.v1.AUTO_REUSE, name=scope) if bn: - temp_conv = tf.layers.batch_normalization( - temp_conv, axis=-1, fused=True, training=training, reuse=tf.AUTO_REUSE, name=scope) - return tf.nn.relu(temp_conv) + temp_conv = tf.compat.v1.layers.batch_normalization( + temp_conv, axis=-1, fused=True, training=training, reuse=tf.compat.v1.AUTO_REUSE, name=scope) + return tf.compat.v1.nn.relu(temp_conv) if(__name__ == "__main__"): From 9807079a0b68439182ed239253c17a4003a655fb Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 12 Jan 2021 19:31:20 +0530 Subject: [PATCH 12/24] Update model.py Made compatible with tf v1 --- model/model.py | 60 +++++++++++++++++++++++++------------------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/model/model.py b/model/model.py index 86aacb8ca..740da366a 100644 --- a/model/model.py +++ b/model/model.py @@ -68,7 +68,7 @@ def __init__(self, training=self.is_train, batch_size=self.single_batch_size) rpn = MiddleAndRPN( input=feature.outputs, alpha=self.alpha, beta=self.beta, training=self.is_train) - tf.get_variable_scope().reuse_variables() + tf.compat.v1.get_variable_scope().reuse_variables() # input self.vox_feature.append(feature.feature) self.vox_number.append(feature.number) @@ -86,15 +86,15 @@ def __init__(self, prob_output = rpn.prob_output # loss and grad if idx == 0: - self.extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) + self.extra_update_ops = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.UPDATE_OPS) self.loss = rpn.loss self.reg_loss = rpn.reg_loss self.cls_loss = rpn.cls_loss self.cls_pos_loss = rpn.cls_pos_loss_rec self.cls_neg_loss = rpn.cls_neg_loss_rec - self.params = tf.trainable_variables() - gradients = tf.gradients(self.loss, self.params) + self.params = tf.compat.v1.trainable_variables() + gradients = tf.compat.v1.gradients(self.loss, self.params) clipped_gradients, gradient_norm = tf.clip_by_global_norm( gradients, max_gradient_norm) @@ -104,7 +104,7 @@ def __init__(self, self.gradient_norm.append(gradient_norm) self.rpn_output_shape = rpn.output_shape - self.vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) + self.vars = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.GLOBAL_VARIABLES) # loss and optimizer # self.xxxloss is only the loss for the lowest tower @@ -117,19 +117,19 @@ def __init__(self, self.update.extend(self.extra_update_ops) self.update = tf.group(*self.update) - self.delta_output = tf.concat(self.delta_output, axis=0) - self.prob_output = tf.concat(self.prob_output, axis=0) + self.delta_output = tf.compat.v1.concat(self.delta_output, axis=0) + self.prob_output = tf.compat.v1.concat(self.prob_output, axis=0) self.anchors = cal_anchors() # for predict and image summary - self.rgb = tf.placeholder( + self.rgb = tf.compat.v1.placeholder( tf.uint8, [None, cfg.IMAGE_HEIGHT, cfg.IMAGE_WIDTH, 3]) - self.bv = tf.placeholder(tf.uint8, [ + self.bv = tf.compat.v1.placeholder(tf.uint8, [ None, cfg.BV_LOG_FACTOR * cfg.INPUT_HEIGHT, cfg.BV_LOG_FACTOR * cfg.INPUT_WIDTH, 3]) - self.bv_heatmap = tf.placeholder(tf.uint8, [ + self.bv_heatmap = tf.compat.v1.placeholder(tf.uint8, [ None, cfg.BV_LOG_FACTOR * cfg.FEATURE_HEIGHT, cfg.BV_LOG_FACTOR * cfg.FEATURE_WIDTH, 3]) - self.boxes2d = tf.placeholder(tf.float32, [None, 4]) - self.boxes2d_scores = tf.placeholder(tf.float32, [None]) + self.boxes2d = tf.compat.v1.placeholder(tf.float32, [None, 4]) + self.boxes2d_scores = tf.compat.v1.placeholder(tf.float32, [None]) # NMS(2D) with tf.device('/gpu:{}'.format(self.avail_gpus[0])): @@ -137,32 +137,32 @@ def __init__(self, self.boxes2d, self.boxes2d_scores, max_output_size=cfg.RPN_NMS_POST_TOPK, iou_threshold=cfg.RPN_NMS_THRESH) # summary and saver - self.saver = tf.train.Saver(write_version=tf.train.SaverDef.V2, + self.saver = tf.compat.v1.train.Saver(write_version=tf.compat.v1.train.SaverDef.V2, max_to_keep=10, pad_step_number=True, keep_checkpoint_every_n_hours=1.0) - self.train_summary = tf.summary.merge([ - tf.summary.scalar('train/loss', self.loss), - tf.summary.scalar('train/reg_loss', self.reg_loss), - tf.summary.scalar('train/cls_loss', self.cls_loss), - tf.summary.scalar('train/cls_pos_loss', self.cls_pos_loss), - tf.summary.scalar('train/cls_neg_loss', self.cls_neg_loss), - *[tf.summary.histogram(each.name, each) for each in self.vars + self.params] + self.train_summary = tf.compat.v1.summary.merge([ + tf.compat.v1.summary.scalar('train/loss', self.loss), + tf.compat.v1.summary.scalar('train/reg_loss', self.reg_loss), + tf.compat.v1.summary.scalar('train/cls_loss', self.cls_loss), + tf.compat.v1.summary.scalar('train/cls_pos_loss', self.cls_pos_loss), + tf.compat.v1.summary.scalar('train/cls_neg_loss', self.cls_neg_loss), + *[tf.compat.v1.summary.histogram(each.name, each) for each in self.vars + self.params] ]) - self.validate_summary = tf.summary.merge([ - tf.summary.scalar('validate/loss', self.loss), - tf.summary.scalar('validate/reg_loss', self.reg_loss), - tf.summary.scalar('validate/cls_loss', self.cls_loss), - tf.summary.scalar('validate/cls_pos_loss', self.cls_pos_loss), - tf.summary.scalar('validate/cls_neg_loss', self.cls_neg_loss) + self.validate_summary = tf.compat.v1.summary.merge([ + tf.compat.v1.summary.scalar('validate/loss', self.loss), + tf.compat.v1.summary.scalar('validate/reg_loss', self.reg_loss), + tf.compat.v1.summary.scalar('validate/cls_loss', self.cls_loss), + tf.compat.v1.summary.scalar('validate/cls_pos_loss', self.cls_pos_loss), + tf.compat.v1.summary.scalar('validate/cls_neg_loss', self.cls_neg_loss) ]) # TODO: bird_view_summary and front_view_summary - self.predict_summary = tf.summary.merge([ - tf.summary.image('predict/bird_view_lidar', self.bv), - tf.summary.image('predict/bird_view_heatmap', self.bv_heatmap), - tf.summary.image('predict/front_view_rgb', self.rgb), + self.predict_summary = tf.compat.v1.summary.merge([ + tf.compat.v1.summary.image('predict/bird_view_lidar', self.bv), + tf.compat.v1.compat.v1.summary.image('predict/bird_view_heatmap', self.bv_heatmap), + tf.compat.v1.summary.image('predict/front_view_rgb', self.rgb), ]) def train_step(self, session, data, train=False, summary=False): From d1fc9d438093b662b9054431bb86a2bff7cd3f80 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 12 Jan 2021 19:37:38 +0530 Subject: [PATCH 13/24] Update train.py made compatible with tf v1 --- train.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/train.py b/train.py index 004fb54c4..63c5177ca 100644 --- a/train.py +++ b/train.py @@ -89,14 +89,14 @@ def main(_): global_counter = model.global_step.eval() + 1 else: print("Created model with fresh parameters.") - tf.global_variables_initializer().run() + tf.compat.v1.global_variables_initializer().run() # train and validate is_summary, is_summary_image, is_validate = False, False, False summary_interval = 5 summary_val_interval = 10 - summary_writer = tf.summary.FileWriter(log_dir, sess.graph) + summary_writer = tf.compat.v1.summary.FileWriter(log_dir, sess.graph) # training From d49ece025bea75c7e02c21bd3d9d6dc894a17199 Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Tue, 12 Jan 2021 22:55:52 +0530 Subject: [PATCH 14/24] Update group_pointcloud.py --- model/group_pointcloud.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/model/group_pointcloud.py b/model/group_pointcloud.py index 884dbf4e7..0384c7c1b 100644 --- a/model/group_pointcloud.py +++ b/model/group_pointcloud.py @@ -25,7 +25,7 @@ def apply(self, inputs, mask, training): pointwise = self.batch_norm.apply(self.dense.apply(inputs), training) #n [K, 1, units] - aggregated = tf.reduce_max(pointwise, axis=1, keep_dims=True) + aggregated = tf.reduce_max(pointwise, axis=1, keepdims=True) # [K, T, units] repeated = tf.tile(aggregated, [1, cfg.VOXEL_POINT_COUNT, 1]) From d408b4cc7414a117ac0ab2cf933d61cc100960a4 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Wed, 13 Jan 2021 13:35:06 +0530 Subject: [PATCH 15/24] Update train.py Changed batch size in line 29, from 2 to 1. --- train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/train.py b/train.py index 63c5177ca..763387d31 100644 --- a/train.py +++ b/train.py @@ -26,7 +26,7 @@ help='max epoch') parser.add_argument('-n', '--tag', type=str, nargs='?', default='default', help='set log tag') -parser.add_argument('-b', '--single-batch-size', type=int, nargs='?', default=2, +parser.add_argument('-b', '--single-batch-size', type=int, nargs='?', default=1, help='set batch size') parser.add_argument('-l', '--lr', type=float, nargs='?', default=0.001, help='set learning rate') From e67a3be2b33dd0faeb8bc616a1891d8b2c5159fa Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Fri, 15 Jan 2021 12:51:35 +0530 Subject: [PATCH 16/24] Update model.py --- model/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/model/model.py b/model/model.py index 740da366a..b9eecc8c2 100644 --- a/model/model.py +++ b/model/model.py @@ -161,7 +161,7 @@ def __init__(self, self.predict_summary = tf.compat.v1.summary.merge([ tf.compat.v1.summary.image('predict/bird_view_lidar', self.bv), - tf.compat.v1.compat.v1.summary.image('predict/bird_view_heatmap', self.bv_heatmap), + tf.compat.v1.summary.image('predict/bird_view_heatmap', self.bv_heatmap), tf.compat.v1.summary.image('predict/front_view_rgb', self.rgb), ]) From e7116b5bdca8a7d2c71e3e4772a3fcb96d6c7b93 Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Fri, 15 Jan 2021 12:53:43 +0530 Subject: [PATCH 17/24] Update group_pointcloud.py --- model/group_pointcloud.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/model/group_pointcloud.py b/model/group_pointcloud.py index 0384c7c1b..ffc031ea9 100644 --- a/model/group_pointcloud.py +++ b/model/group_pointcloud.py @@ -52,7 +52,7 @@ def __init__(self, training, batch_size, name=''): self.feature = tf.compat.v1.placeholder( tf.float32, [None, cfg.VOXEL_POINT_COUNT, 7], name='feature') # [ΣK] - self.number = tf.compat.v1.compat.v1.placeholder(tf.int64, [None], name='number') + self.number = tf.compat.v1.placeholder(tf.int64, [None], name='number') # [ΣK, 4], each row stores (batch, d, h, w) self.coordinate = tf.compat.v1.placeholder( tf.int64, [None, 4], name='coordinate') From e83cdf9e4afc710f664c3d99c57eb8a65437cde3 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 19 Jan 2021 00:37:56 +0530 Subject: [PATCH 18/24] Update train.py Added comment explaining argparse functions --- train.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/train.py b/train.py index 763387d31..fca71257f 100644 --- a/train.py +++ b/train.py @@ -40,6 +40,10 @@ help='set the flag to True if dumping visualizations') args = parser.parse_args() +# Used to parse command line arguments as the name suggests. +#Links +#Documentation-https://docs.python.org/3/library/argparse.html +#Easier explanation-https://mkaz.blog/code/python-argparse-cookbook/ dataset_dir = cfg.DATA_DIR train_dir = os.path.join(cfg.DATA_DIR, 'training') From 1327848ab432ea90c6eeec2b7339e8a2a3ccd601 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Tue, 19 Jan 2021 19:06:54 +0530 Subject: [PATCH 19/24] Update train.py Added links for understanding tf.Graph(), tf.sess() --- train.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/train.py b/train.py index fca71257f..79a367da8 100644 --- a/train.py +++ b/train.py @@ -56,8 +56,8 @@ def main(_): # TODO: split file support - with tf.Graph().as_default(): - global save_model_dir + with tf.Graph().as_default(): #tf.Graph and Session explained-https://www.easy-tensorflow.com/tf-tutorials/basics/graph-and-session + global save_model_dir # Also- "https://www.easy-tensorflow.com/tf-tutorials/basics/graph-and-session" for as_default() function. start_epoch = 0 global_counter = 0 From c47016f813e483c6a611e07788633a68bd343517 Mon Sep 17 00:00:00 2001 From: anshul22negi <56079693+anshul22negi@users.noreply.github.com> Date: Sun, 31 Jan 2021 20:18:52 +0530 Subject: [PATCH 20/24] Added datasplit.py Allows for splitting raw Kitti data into training and validation sets --- datasplit.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 datasplit.py diff --git a/datasplit.py b/datasplit.py new file mode 100644 index 000000000..95061e3cb --- /dev/null +++ b/datasplit.py @@ -0,0 +1,28 @@ +import os +import shutil + +dir="D:\VoxelNet-tensorflow\data_object_velodyne\\training\\velodyne" +#dir="D:\VoxelNet-tensorflow\data_object_label_2\\training\label_2" +#dir="D:\VoxelNet-tensorflow\data_object_image_2\\training\image_2" +val_find="D:\\val.txt" +dest="D:\VoxelNet-tensorflow\data_object_velodyne\\validation\\velodyne" +#dest="D:\VoxelNet-tensorflow\data_object_label_2\\validation\label_2" +#dest="D:\VoxelNet-tensorflow\data_object_image_2\\validation\image_2" + +#dest="D:\VoxelNet-tensorflow\data_object_velodyne\\train\\velodyne" +#dest="D:\VoxelNet-tensorflow\data_object_label_2\\train\label_2" +#dest="D:\VoxelNet-tensorflow\data_object_image_2\\train\image_2" + +num=[] +with open(val_find) as vf: + for i in vf: + i=i.split() + num.append(i[0]+'.bin') + #num.append(i[0]+'.txt') + #num.append(i[0]+'.png') +print(dest) + +os.makedirs(dest) +for i in num: + shutil.move(os.path.join(dir,i),dest) +#shutil.move('D:\\000000.bin',dest) From 764a18e95ecd5729cbf0a5c90862c0e3ae855cad Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Fri, 19 Mar 2021 13:50:41 +0530 Subject: [PATCH 21/24] Update README.md --- README.md | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 4d700019d..19130c9ee 100644 --- a/README.md +++ b/README.md @@ -66,13 +66,6 @@ Note that the hyper-parameter settings introduced in the paper are not able to p Training on two Nvidia 1080 Ti GPUs takes around 3 days (160 epochs as reported in the paper). During training, training statistics are recorded in `log/default`, which can be monitored by tensorboard. And models are saved in `save_model/default`. Intermediate validation results will be dumped into the folder `predictions/XXX/data` with `XXX` as the epoch number. And metrics will be calculated and saved in `predictions/XXX/log`. If the `--vis` flag is set to be `True`, visualizations of intermediate results will be dumped in the folder `predictions/XXX/vis`. -3. When the training is done, executing `parse_log.py` will generate the learning curve. -```bash -$ python3 parse_log.py predictions -``` - -4. There is a pre-trained model for car in `save_model/pre_trained_car`. - # Evaluate 1. run `test.py -n default` to produce final predictions on the validation set after training is done. Change `-n` flag to `pre_trained_car` will start testing for the pre-trained model (only car model provided for now). @@ -86,6 +79,11 @@ results will be dumped into `predictions/data`. Set the `--vis` flag to True if $ ./kitti_eval/evaluate_object_3d_offline [DATA_DIR]/validation/label_2 ./predictions ``` +3. When the testing is done, executing `parse_log.py` will generate the learning curve. +```bash +$ python3 parse_log.py predictions +``` + # Performances The current implementation and training scheme are able to produce results in the tables below. From b07d602acec642a7eef51078bcbcc260b6e19e45 Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Fri, 19 Mar 2021 14:02:26 +0530 Subject: [PATCH 22/24] Update README.md --- README.md | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 19130c9ee..832cd3879 100644 --- a/README.md +++ b/README.md @@ -66,6 +66,10 @@ Note that the hyper-parameter settings introduced in the paper are not able to p Training on two Nvidia 1080 Ti GPUs takes around 3 days (160 epochs as reported in the paper). During training, training statistics are recorded in `log/default`, which can be monitored by tensorboard. And models are saved in `save_model/default`. Intermediate validation results will be dumped into the folder `predictions/XXX/data` with `XXX` as the epoch number. And metrics will be calculated and saved in `predictions/XXX/log`. If the `--vis` flag is set to be `True`, visualizations of intermediate results will be dumped in the folder `predictions/XXX/vis`. +3. When the testing is done, executing `parse_log.py` will generate the learning curve. +```bash +$ python3 parse_log.py predictions +``` # Evaluate 1. run `test.py -n default` to produce final predictions on the validation set after training is done. Change `-n` flag to `pre_trained_car` will start testing for the pre-trained model (only car model provided for now). @@ -79,11 +83,6 @@ results will be dumped into `predictions/data`. Set the `--vis` flag to True if $ ./kitti_eval/evaluate_object_3d_offline [DATA_DIR]/validation/label_2 ./predictions ``` -3. When the testing is done, executing `parse_log.py` will generate the learning curve. -```bash -$ python3 parse_log.py predictions -``` - # Performances The current implementation and training scheme are able to produce results in the tables below. From f354c7928a98ad42ae8b5aef318fbeb19386d8a7 Mon Sep 17 00:00:00 2001 From: Bhoopen <62685221+kasai2210@users.noreply.github.com> Date: Fri, 19 Mar 2021 14:02:50 +0530 Subject: [PATCH 23/24] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 832cd3879..320148391 100644 --- a/README.md +++ b/README.md @@ -66,7 +66,7 @@ Note that the hyper-parameter settings introduced in the paper are not able to p Training on two Nvidia 1080 Ti GPUs takes around 3 days (160 epochs as reported in the paper). During training, training statistics are recorded in `log/default`, which can be monitored by tensorboard. And models are saved in `save_model/default`. Intermediate validation results will be dumped into the folder `predictions/XXX/data` with `XXX` as the epoch number. And metrics will be calculated and saved in `predictions/XXX/log`. If the `--vis` flag is set to be `True`, visualizations of intermediate results will be dumped in the folder `predictions/XXX/vis`. -3. When the testing is done, executing `parse_log.py` will generate the learning curve. +3. When the training is done, executing `parse_log.py` will generate the learning curve. ```bash $ python3 parse_log.py predictions ``` From 540578499371b0763996eec08626a42cb15a1616 Mon Sep 17 00:00:00 2001 From: kasai2210 Date: Sat, 31 Jul 2021 18:22:04 +0000 Subject: [PATCH 24/24] some fixes --- config.py | 6 +- data/crop.py | 6 +- datasplit.py | 18 +- img/learning_curve.jpg | Bin 90876 -> 0 bytes kitti_eval/launch_test.sh | 2 +- model/model.py | 98 +- parse_log.py | 11 +- test.py | 17 +- train.py | 16 +- utils/box_overlaps.c | 7016 ++++++++++++++++--------------------- utils/utils.py | 2 +- 11 files changed, 3097 insertions(+), 4095 deletions(-) delete mode 100644 img/learning_curve.jpg diff --git a/config.py b/config.py index e27f96429..fd7b492a6 100644 --- a/config.py +++ b/config.py @@ -18,12 +18,12 @@ cfg = __C # for dataset dir -__C.DATA_DIR = '/media/hdc/KITTI/for_voxelnet/cropped_dataset' -__C.CALIB_DIR = '/media/hdc/KITTI/calib/data_object_calib/training/calib' +__C.DATA_DIR = '/home/anshul/Project/voxelnet-1/data_dir' +__C.CALIB_DIR = '/home/anshul/Project/voxelnet-1/data_object_calib/training/calib' # for gpu allocation -__C.GPU_AVAILABLE = '0,1' +__C.GPU_AVAILABLE = '0,1,2' __C.GPU_USE_COUNT = len(__C.GPU_AVAILABLE.split(',')) __C.GPU_MEMORY_FRACTION = 1 diff --git a/data/crop.py b/data/crop.py index 805e7a1d6..8a62b6132 100644 --- a/data/crop.py +++ b/data/crop.py @@ -80,9 +80,9 @@ def align_img_and_pc(img_dir, pc_dir, calib_dir): return points # update the following directories -IMG_ROOT = "D:\VoxelNet-tensorflow\data_object_image_2\\training\image_2\\" -PC_ROOT = "D:\VoxelNet-tensorflow\data_object_velodyne\\training\\velodyne\\" -CALIB_ROOT = "D:\VoxelNet-tensorflow\data_object_calib\\training\calib\\" +IMG_ROOT = "/home/anshul/Project/voxelnet-1/data_object_image_2/training/image_2/" +PC_ROOT = "/home/anshul/Project/voxelnet-1/data_object_velodyne/training/velodyne/" +CALIB_ROOT = "/home/anshul/Project/voxelnet-1/data_object_calib/training/calib/" diff --git a/datasplit.py b/datasplit.py index 95061e3cb..47e4c218e 100644 --- a/datasplit.py +++ b/datasplit.py @@ -1,13 +1,13 @@ import os import shutil -dir="D:\VoxelNet-tensorflow\data_object_velodyne\\training\\velodyne" -#dir="D:\VoxelNet-tensorflow\data_object_label_2\\training\label_2" -#dir="D:\VoxelNet-tensorflow\data_object_image_2\\training\image_2" -val_find="D:\\val.txt" -dest="D:\VoxelNet-tensorflow\data_object_velodyne\\validation\\velodyne" -#dest="D:\VoxelNet-tensorflow\data_object_label_2\\validation\label_2" -#dest="D:\VoxelNet-tensorflow\data_object_image_2\\validation\image_2" +#dir="/home/anshul/Project/voxelnet-1/data_object_velodyne/training/velodyne" +#dir="/home/anshul/Project/voxelnet-1/data_object_label_2/training/label_2" +dir="/home/anshul/Project/voxelnet-1/data_object_image_2/training/image_2" +val_find="/home/anshul/Project/voxelnet-1/val.txt" +#dest="/home/anshul/Project/voxelnet-1/data_object_velodyne/validation/velodyne" +#dest="/home/anshul/Project/voxelnet-1/data_object_label_2/validation/label_2" +dest="/home/anshul/Project/voxelnet-1/data_object_image_2/validation/image_2" #dest="D:\VoxelNet-tensorflow\data_object_velodyne\\train\\velodyne" #dest="D:\VoxelNet-tensorflow\data_object_label_2\\train\label_2" @@ -17,9 +17,9 @@ with open(val_find) as vf: for i in vf: i=i.split() - num.append(i[0]+'.bin') + #num.append(i[0]+'.bin') #num.append(i[0]+'.txt') - #num.append(i[0]+'.png') + num.append(i[0]+'.png') print(dest) os.makedirs(dest) diff --git a/img/learning_curve.jpg b/img/learning_curve.jpg deleted file mode 100644 index bd979192c04824cb4726a07e744605f6cab4c12c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 90876 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 diff --git a/kitti_eval/launch_test.sh b/kitti_eval/launch_test.sh index fb9aa18fa..cd24e70d1 100755 --- a/kitti_eval/launch_test.sh +++ b/kitti_eval/launch_test.sh @@ -1,5 +1,5 @@ # crooped gt dir -GT_DIR=/media/hdc/KITTI/for_voxelnet/cropped_dataset/validation/label_2 +GT_DIR=/home/anshul/Project/voxelnet-1/data_dir/validation/label_2 # pred dir PRED_DIR=$1 diff --git a/model/model.py b/model/model.py index b9eecc8c2..10c409720 100644 --- a/model/model.py +++ b/model/model.py @@ -27,10 +27,10 @@ def __init__(self, # hyper parameters and status self.cls = cls self.single_batch_size = single_batch_size - self.learning_rate = tf.Variable( - float(learning_rate), trainable=False, dtype=tf.float32) - self.global_step = tf.Variable(1, trainable=False) - self.epoch = tf.Variable(0, trainable=False) + self.learning_rate = tf.compat.v1.Variable( + float(learning_rate), trainable=False, dtype=tf.compat.v1.float32) + self.global_step = tf.compat.v1.Variable(1, trainable=False) + self.epoch = tf.compat.v1.Variable(0, trainable=False) self.epoch_add_op = self.epoch.assign(self.epoch + 1) self.alpha = alpha self.beta = beta @@ -38,11 +38,11 @@ def __init__(self, boundaries = [80, 120] values = [ self.learning_rate, self.learning_rate * 0.1, self.learning_rate * 0.01 ] - lr = tf.compat.v1.train.piecewise_constant(self.epoch, boundaries, values) + lr = tf.compat.v1.compat.v1.train.piecewise_constant(self.epoch, boundaries, values) # build graph # input placeholders - self.is_train = tf.compat.v1.placeholder(tf.bool, name='phase') + self.is_train = tf.compat.v1.compat.v1.placeholder(tf.compat.v1.bool, name='phase') self.vox_feature = [] self.vox_number = [] @@ -56,19 +56,19 @@ def __init__(self, self.delta_output = [] self.prob_output = [] - self.opt = tf.compat.v1.train.AdamOptimizer(lr) + self.opt = tf.compat.v1.compat.v1.train.AdamOptimizer(lr) self.gradient_norm = [] self.tower_grads = [] - with tf.compat.v1.variable_scope(tf.compat.v1.get_variable_scope()): + with tf.compat.v1.compat.v1.variable_scope(tf.compat.v1.compat.v1.get_variable_scope()): for idx, dev in enumerate(self.avail_gpus): - with tf.device('/gpu:{}'.format(dev)), tf.name_scope('gpu_{}'.format(dev)): + with tf.compat.v1.device('/gpu:{}'.format(dev)), tf.compat.v1.name_scope('gpu_{}'.format(dev)): # must use name scope here since we do not want to create new variables # graph feature = FeatureNet( training=self.is_train, batch_size=self.single_batch_size) rpn = MiddleAndRPN( input=feature.outputs, alpha=self.alpha, beta=self.beta, training=self.is_train) - tf.compat.v1.get_variable_scope().reuse_variables() + tf.compat.v1.compat.v1.get_variable_scope().reuse_variables() # input self.vox_feature.append(feature.feature) self.vox_number.append(feature.number) @@ -86,16 +86,16 @@ def __init__(self, prob_output = rpn.prob_output # loss and grad if idx == 0: - self.extra_update_ops = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.UPDATE_OPS) + self.extra_update_ops = tf.compat.v1.compat.v1.get_collection(tf.compat.v1.compat.v1.GraphKeys.UPDATE_OPS) self.loss = rpn.loss self.reg_loss = rpn.reg_loss self.cls_loss = rpn.cls_loss self.cls_pos_loss = rpn.cls_pos_loss_rec self.cls_neg_loss = rpn.cls_neg_loss_rec - self.params = tf.compat.v1.trainable_variables() - gradients = tf.compat.v1.gradients(self.loss, self.params) - clipped_gradients, gradient_norm = tf.clip_by_global_norm( + self.params = tf.compat.v1.compat.v1.trainable_variables() + gradients = tf.compat.v1.compat.v1.gradients(self.loss, self.params) + clipped_gradients, gradient_norm = tf.compat.v1.clip_by_global_norm( gradients, max_gradient_norm) self.delta_output.append(delta_output) @@ -104,65 +104,65 @@ def __init__(self, self.gradient_norm.append(gradient_norm) self.rpn_output_shape = rpn.output_shape - self.vars = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.GLOBAL_VARIABLES) + self.vars = tf.compat.v1.compat.v1.get_collection(tf.compat.v1.compat.v1.GraphKeys.GLOBAL_VARIABLES) # loss and optimizer # self.xxxloss is only the loss for the lowest tower - with tf.device('/gpu:{}'.format(self.avail_gpus[0])): + with tf.compat.v1.device('/gpu:{}'.format(self.avail_gpus[0])): self.grads = average_gradients(self.tower_grads) self.update = [self.opt.apply_gradients( zip(self.grads, self.params), global_step=self.global_step)] - self.gradient_norm = tf.group(*self.gradient_norm) + self.gradient_norm = tf.compat.v1.group(*self.gradient_norm) self.update.extend(self.extra_update_ops) - self.update = tf.group(*self.update) + self.update = tf.compat.v1.group(*self.update) - self.delta_output = tf.compat.v1.concat(self.delta_output, axis=0) - self.prob_output = tf.compat.v1.concat(self.prob_output, axis=0) + self.delta_output = tf.compat.v1.compat.v1.concat(self.delta_output, axis=0) + self.prob_output = tf.compat.v1.compat.v1.concat(self.prob_output, axis=0) self.anchors = cal_anchors() # for predict and image summary - self.rgb = tf.compat.v1.placeholder( - tf.uint8, [None, cfg.IMAGE_HEIGHT, cfg.IMAGE_WIDTH, 3]) - self.bv = tf.compat.v1.placeholder(tf.uint8, [ + self.rgb = tf.compat.v1.compat.v1.placeholder( + tf.compat.v1.uint8, [None, cfg.IMAGE_HEIGHT, cfg.IMAGE_WIDTH, 3]) + self.bv = tf.compat.v1.compat.v1.placeholder(tf.compat.v1.uint8, [ None, cfg.BV_LOG_FACTOR * cfg.INPUT_HEIGHT, cfg.BV_LOG_FACTOR * cfg.INPUT_WIDTH, 3]) - self.bv_heatmap = tf.compat.v1.placeholder(tf.uint8, [ + self.bv_heatmap = tf.compat.v1.compat.v1.placeholder(tf.compat.v1.uint8, [ None, cfg.BV_LOG_FACTOR * cfg.FEATURE_HEIGHT, cfg.BV_LOG_FACTOR * cfg.FEATURE_WIDTH, 3]) - self.boxes2d = tf.compat.v1.placeholder(tf.float32, [None, 4]) - self.boxes2d_scores = tf.compat.v1.placeholder(tf.float32, [None]) + self.boxes2d = tf.compat.v1.compat.v1.placeholder(tf.compat.v1.float32, [None, 4]) + self.boxes2d_scores = tf.compat.v1.compat.v1.placeholder(tf.compat.v1.float32, [None]) # NMS(2D) - with tf.device('/gpu:{}'.format(self.avail_gpus[0])): - self.box2d_ind_after_nms = tf.image.non_max_suppression( + with tf.compat.v1.device('/gpu:{}'.format(self.avail_gpus[0])): + self.box2d_ind_after_nms = tf.compat.v1.image.non_max_suppression( self.boxes2d, self.boxes2d_scores, max_output_size=cfg.RPN_NMS_POST_TOPK, iou_threshold=cfg.RPN_NMS_THRESH) # summary and saver - self.saver = tf.compat.v1.train.Saver(write_version=tf.compat.v1.train.SaverDef.V2, + self.saver = tf.compat.v1.compat.v1.train.Saver(write_version=tf.compat.v1.compat.v1.train.SaverDef.V2, max_to_keep=10, pad_step_number=True, keep_checkpoint_every_n_hours=1.0) - self.train_summary = tf.compat.v1.summary.merge([ - tf.compat.v1.summary.scalar('train/loss', self.loss), - tf.compat.v1.summary.scalar('train/reg_loss', self.reg_loss), - tf.compat.v1.summary.scalar('train/cls_loss', self.cls_loss), - tf.compat.v1.summary.scalar('train/cls_pos_loss', self.cls_pos_loss), - tf.compat.v1.summary.scalar('train/cls_neg_loss', self.cls_neg_loss), - *[tf.compat.v1.summary.histogram(each.name, each) for each in self.vars + self.params] + self.train_summary = tf.compat.v1.compat.v1.summary.merge([ + tf.compat.v1.compat.v1.summary.scalar('train/loss', self.loss), + tf.compat.v1.compat.v1.summary.scalar('train/reg_loss', self.reg_loss), + tf.compat.v1.compat.v1.summary.scalar('train/cls_loss', self.cls_loss), + tf.compat.v1.compat.v1.summary.scalar('train/cls_pos_loss', self.cls_pos_loss), + tf.compat.v1.compat.v1.summary.scalar('train/cls_neg_loss', self.cls_neg_loss), + *[tf.compat.v1.compat.v1.summary.histogram(each.name, each) for each in self.vars + self.params] ]) - self.validate_summary = tf.compat.v1.summary.merge([ - tf.compat.v1.summary.scalar('validate/loss', self.loss), - tf.compat.v1.summary.scalar('validate/reg_loss', self.reg_loss), - tf.compat.v1.summary.scalar('validate/cls_loss', self.cls_loss), - tf.compat.v1.summary.scalar('validate/cls_pos_loss', self.cls_pos_loss), - tf.compat.v1.summary.scalar('validate/cls_neg_loss', self.cls_neg_loss) + self.validate_summary = tf.compat.v1.compat.v1.summary.merge([ + tf.compat.v1.compat.v1.summary.scalar('validate/loss', self.loss), + tf.compat.v1.compat.v1.summary.scalar('validate/reg_loss', self.reg_loss), + tf.compat.v1.compat.v1.summary.scalar('validate/cls_loss', self.cls_loss), + tf.compat.v1.compat.v1.summary.scalar('validate/cls_pos_loss', self.cls_pos_loss), + tf.compat.v1.compat.v1.summary.scalar('validate/cls_neg_loss', self.cls_neg_loss) ]) # TODO: bird_view_summary and front_view_summary - self.predict_summary = tf.compat.v1.summary.merge([ - tf.compat.v1.summary.image('predict/bird_view_lidar', self.bv), - tf.compat.v1.summary.image('predict/bird_view_heatmap', self.bv_heatmap), - tf.compat.v1.summary.image('predict/front_view_rgb', self.rgb), + self.predict_summary = tf.compat.v1.compat.v1.summary.merge([ + tf.compat.v1.compat.v1.summary.image('predict/bird_view_lidar', self.bv), + tf.compat.v1.compat.v1.summary.image('predict/bird_view_heatmap', self.bv_heatmap), + tf.compat.v1.compat.v1.summary.image('predict/front_view_rgb', self.rgb), ]) def train_step(self, session, data, train=False, summary=False): @@ -375,14 +375,14 @@ def average_gradients(tower_grads): grads = [] for g in grad_and_vars: # Add 0 dimension to the gradients to represent the tower. - expanded_g = tf.expand_dims(g, 0) + expanded_g = tf.compat.v1.expand_dims(g, 0) # Append on a 'tower' dimension which we will average over below. grads.append(expanded_g) # Average over the 'tower' dimension. - grad = tf.concat(axis=0, values=grads) - grad = tf.reduce_mean(grad, 0) + grad = tf.compat.v1.concat(axis=0, values=grads) + grad = tf.compat.v1.reduce_mean(grad, 0) # Keep in mind that the Variables are redundant because they are shared # across towers. So .. we will just return the first tower's pointer to diff --git a/parse_log.py b/parse_log.py index d7aa0dfbc..5d068394b 100644 --- a/parse_log.py +++ b/parse_log.py @@ -61,13 +61,12 @@ plt.figure(figsize=(10, 7)) -plt.plot( RANGE, det_3d[0] , linestyle=linestyles['solid'], linewidth=1.5, color=tableau20[0] ) -plt.plot( RANGE, det_3d[1] , linestyle=linestyles['solid'], linewidth=1.5, color=tableau20[2] ) -plt.plot( RANGE, det_3d[2] , linestyle=linestyles['solid'], linewidth=1.5, color=tableau20[4] ) +#plt.plot( RANGE, det_3d[0] , linestyle=linestyles['solid'], linewidth=1.5, color=tableau20[0] ) +#plt.plot( RANGE, det_3d[1] , linestyle=linestyles['solid'], linewidth=1.5, color=tableau20[2] ) +#plt.plot( RANGE, det_3d[2] , linestyle=linestyles['solid'], linewidth=1.5, color=tableau20[4] ) plt.plot( RANGE, det_bv[0] , linestyle=linestyles['densely dotted'], linewidth=1.5, color=tableau20[0] ) -plt.plot( RANGE, det_bv[1] , linestyle=linestyles['densely dotted'], linewidth=1.5, color=tableau20[2] ) -plt.plot( RANGE, det_bv[2] , linestyle=linestyles['densely dotted'], linewidth=1.5, color=tableau20[4] ) - +#plt.plot( RANGE, det_bv[1] , linestyle=linestyles['densely dotted'], linewidth=1.5, color=tableau20[2] ) +#plt.plot( RANGE, det_bv[2] , linestyle=linestyles['densely dotted'], linewidth=1.5, color=tableau20[4] ) plt.legend(['3d easy', '3d moderate', '3d hard', 'bird view easy', 'bird view moderate', 'bird view hard'], loc=4) diff --git a/test.py b/test.py index 449f3d232..b3dcea1b1 100644 --- a/test.py +++ b/test.py @@ -20,14 +20,15 @@ help='set log tag') parser.add_argument('--output-path', type=str, nargs='?', default='./predictions', help='results output dir') - parser.add_argument('-b', '--single-batch-size', type=int, nargs='?', default=2, + parser.add_argument('-b', '--single-batch-size', type=int, nargs='?', default=1, help='set batch size for each gpu') - parser.add_argument('-v', '--vis', type=bool, nargs='?', default=False, + parser.add_argument('-v', '--vis', type=bool, nargs='?', default=True, help='set the flag to True if dumping visualizations') args = parser.parse_args() dataset_dir = cfg.DATA_DIR val_dir = os.path.join(cfg.DATA_DIR, 'validation') + #val_dir="/home/anshul/Project/Test_Bhoopen" save_model_dir = os.path.join('./save_model', args.tag) # create output folder @@ -37,13 +38,13 @@ os.makedirs(os.path.join(args.output_path, 'vis'), exist_ok=True) - with tf.Graph().as_default(): + with tf.compat.v1.Graph().as_default(): - gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=cfg.GPU_MEMORY_FRACTION, + gpu_options = tf.compat.v1.GPUOptions(per_process_gpu_memory_fraction=cfg.GPU_MEMORY_FRACTION, visible_device_list=cfg.GPU_AVAILABLE, allow_growth=True) - config = tf.ConfigProto( + config = tf.compat.v1.ConfigProto( gpu_options=gpu_options, device_count={ "GPU": cfg.GPU_USE_COUNT, @@ -51,16 +52,16 @@ allow_soft_placement=True, ) - with tf.Session(config=config) as sess: + with tf.compat.v1.Session(config=config) as sess: model = RPN3D( cls=cfg.DETECT_OBJ, single_batch_size=args.single_batch_size, avail_gpus=cfg.GPU_AVAILABLE.split(',') ) - if tf.train.get_checkpoint_state(save_model_dir): + if tf.compat.v1.train.get_checkpoint_state(save_model_dir): print("Reading model parameters from %s" % save_model_dir) model.saver.restore( - sess, tf.train.latest_checkpoint(save_model_dir)) + sess, tf.compat.v1.train.latest_checkpoint(save_model_dir)) for batch in iterate_data(val_dir, shuffle=False, aug=False, is_testset=False, batch_size=args.single_batch_size * cfg.GPU_USE_COUNT, multi_gpu_sum=cfg.GPU_USE_COUNT): diff --git a/train.py b/train.py index 79a367da8..14273cc98 100644 --- a/train.py +++ b/train.py @@ -8,7 +8,7 @@ import time import sys import tensorflow as tf -#import tensorflow.compat.v1 as tf +#import tensorflow.compat.v1 as tf.compat.v1 from itertools import count @@ -36,7 +36,7 @@ help='set beta in los function') parser.add_argument('--output-path', type=str, nargs='?', default='./predictions', help='results output dir') -parser.add_argument('-v', '--vis', type=bool, nargs='?', default=False, +parser.add_argument('-v', '--vis', type=bool, nargs='?', default=True, help='set the flag to True if dumping visualizations') args = parser.parse_args() @@ -56,12 +56,12 @@ def main(_): # TODO: split file support - with tf.Graph().as_default(): #tf.Graph and Session explained-https://www.easy-tensorflow.com/tf-tutorials/basics/graph-and-session - global save_model_dir # Also- "https://www.easy-tensorflow.com/tf-tutorials/basics/graph-and-session" for as_default() function. + with tf.compat.v1.Graph().as_default(): #tf.compat.v1.Graph and Session explained-https://www.easy-tensorflow.com/tf.compat.v1-tutorials/basics/graph-and-session + global save_model_dir # Also- "https://www.easy-tensorflow.com/tf.compat.v1-tutorials/basics/graph-and-session" for as_default() function. start_epoch = 0 global_counter = 0 - #gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=cfg.GPU_MEMORY_FRACTION, + #gpu_options = tf.compat.v1.GPUOptions(per_process_gpu_memory_fraction=cfg.GPU_MEMORY_FRACTION, # visible_device_list=cfg.GPU_AVAILABLE, # allow_growth=True) gpu_options = tf.compat.v1.GPUOptions(per_process_gpu_memory_fraction=cfg.GPU_MEMORY_FRACTION, @@ -85,10 +85,10 @@ def main(_): avail_gpus=cfg.GPU_AVAILABLE.split(',') ) # param init/restore - if tf.train.get_checkpoint_state(save_model_dir): + if tf.compat.v1.train.get_checkpoint_state(save_model_dir): print("Reading model parameters from %s" % save_model_dir) model.saver.restore( - sess, tf.train.latest_checkpoint(save_model_dir)) + sess, tf.compat.v1.train.latest_checkpoint(save_model_dir)) start_epoch = model.epoch.eval() + 1 global_counter = model.global_step.eval() + 1 else: @@ -206,5 +206,5 @@ def main(_): if __name__ == '__main__': - #tf.app.run(main) + #tf.compat.v1.app.run(main) tf.compat.v1.app.run(main) diff --git a/utils/box_overlaps.c b/utils/box_overlaps.c index 640d72eac..5e021e553 100644 --- a/utils/box_overlaps.c +++ b/utils/box_overlaps.c @@ -1,4 +1,4 @@ -/* Generated by Cython 0.26.1 */ +/* Generated by Cython 0.29.22 */ /* BEGIN: Cython Metadata { @@ -17,10 +17,12 @@ END: Cython Metadata */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) - #error Cython requires Python 2.6+ or Python 3.2+. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. #else -#define CYTHON_ABI "0_26_1" +#define CYTHON_ABI "0_29_22" +#define CYTHON_HEX_VERSION 0x001D16F0 +#define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) @@ -44,7 +46,7 @@ END: Cython Metadata */ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000) + #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif @@ -62,8 +64,12 @@ END: Cython Metadata */ #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS @@ -82,6 +88,14 @@ END: Cython Metadata */ #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 @@ -115,6 +129,14 @@ END: Cython Metadata */ #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 @@ -167,6 +189,18 @@ END: Cython Metadata */ #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) @@ -176,7 +210,107 @@ END: Cython Metadata */ #undef SHIFT #undef BASE #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif @@ -189,8 +323,13 @@ END: Cython Metadata */ #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" +#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES @@ -205,12 +344,15 @@ END: Cython Metadata */ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif -#if PY_VERSION_HEX < 0x030700A0 || !defined(METH_FASTCALL) +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif - typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, Py_ssize_t nargs); - typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject **args, + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast @@ -218,10 +360,83 @@ END: Cython Metadata */ #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))))) + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ @@ -233,7 +448,11 @@ END: Cython Metadata */ #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 @@ -266,20 +485,8 @@ END: Cython Metadata */ #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) - #define PyObject_Malloc(s) PyMem_Malloc(s) - #define PyObject_Free(p) PyMem_Free(p) - #define PyObject_Realloc(p) PyMem_Realloc(p) -#endif -#if CYTHON_COMPILING_IN_PYSTON - #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) -#else - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) -#endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else @@ -294,6 +501,9 @@ END: Cython Metadata */ #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) @@ -305,8 +515,18 @@ END: Cython Metadata */ #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type @@ -341,167 +561,78 @@ END: Cython Metadata */ #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif -#ifndef __has_attribute - #define __has_attribute(x) 0 -#endif -#ifndef __has_cpp_attribute - #define __has_cpp_attribute(x) 0 -#endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif -#ifndef CYTHON_RESTRICT - #if defined(__GNUC__) - #define CYTHON_RESTRICT __restrict__ - #elif defined(_MSC_VER) && _MSC_VER >= 1400 - #define CYTHON_RESTRICT __restrict - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_RESTRICT restrict - #else - #define CYTHON_RESTRICT - #endif -#endif -#ifndef CYTHON_UNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR -# if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } -# else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) -# endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES #endif -#ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON -# define CYTHON_NCP_UNUSED -# else -# define CYTHON_NCP_UNUSED CYTHON_UNUSED -# endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} #endif -#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) -#ifdef _MSC_VER - #ifndef _MSC_STDINT_H_ - #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; - #endif - #endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc #else - #include +#define __Pyx_truncl truncl #endif -#ifndef CYTHON_FALLTHROUGH + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C #ifdef __cplusplus - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_attribute(fallthrough) || (defined(__GNUC__) && defined(__attribute__)) - #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) - #else - #define CYTHON_FALLTHROUGH - #endif - #endif -#endif - -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #elif defined(__GNUC__) - #define CYTHON_INLINE __inline__ - #elif defined(_MSC_VER) - #define CYTHON_INLINE __inline - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_INLINE inline - #else - #define CYTHON_INLINE - #endif -#endif - -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES -#endif -#include -#ifdef NAN -#define __PYX_NAN() ((float) NAN) -#else -static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; -} -#endif -#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) -#define __Pyx_truncl trunc -#else -#define __Pyx_truncl truncl -#endif - - -#define __PYX_ERR(f_index, lineno, Ln_error) \ -{ \ - __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ -} - -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif - -#ifndef __PYX_EXTERN_C - #ifdef __cplusplus - #define __PYX_EXTERN_C extern "C" - #else - #define __PYX_EXTERN_C extern + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__utils__box_overlaps #define __PYX_HAVE_API__utils__box_overlaps +/* Early includes */ #include #include -#include #include "numpy/arrayobject.h" +#include "numpy/ndarrayobject.h" +#include "numpy/ndarraytypes.h" +#include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" + + /* NumPy API declarations from "numpy/__init__.pxd" */ + #ifdef _OPENMP #include #endif /* _OPENMP */ -#ifdef PYREX_WITHOUT_ASSERTIONS +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif @@ -509,7 +640,8 @@ typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* enc const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize @@ -525,6 +657,9 @@ typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* enc (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) @@ -532,8 +667,8 @@ typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* enc #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) -#elif defined (_MSC_VER) && defined (_M_X64) - #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) @@ -555,6 +690,12 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) @@ -565,24 +706,22 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#if PY_MAJOR_VERSION < 3 -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) -{ +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } -#else -#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen -#endif #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS @@ -660,7 +799,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); @@ -683,10 +822,10 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } -static PyObject *__pyx_m; +static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime; +static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; @@ -760,7 +899,7 @@ typedef struct { } __Pyx_BufFmt_Context; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":725 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":690 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -769,7 +908,7 @@ typedef struct { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":726 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":691 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -778,7 +917,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":727 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":692 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -787,7 +926,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":728 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":693 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -796,7 +935,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":732 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":697 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -805,7 +944,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":733 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":698 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -814,7 +953,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":734 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":699 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -823,7 +962,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":735 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":700 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -832,7 +971,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":739 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":704 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -841,7 +980,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":740 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":705 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -850,7 +989,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":749 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":714 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -859,7 +998,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":750 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":715 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -868,7 +1007,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":751 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":716 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -877,7 +1016,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":753 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":718 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -886,7 +1025,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":754 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":719 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -895,7 +1034,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":755 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":720 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -904,7 +1043,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":757 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":722 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -913,7 +1052,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":758 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":723 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -922,7 +1061,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":760 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":725 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -931,7 +1070,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":761 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":726 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -940,7 +1079,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":762 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":727 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -984,7 +1123,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do /*--- Type declarations ---*/ -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":764 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":729 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -993,7 +1132,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":765 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":730 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -1002,7 +1141,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":766 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":731 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -1011,7 +1150,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":768 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":733 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -1086,16 +1225,7 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif @@ -1116,23 +1246,78 @@ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ const char* function_name); /* ArgTypeTest.proto */ -static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, - const char *name, int exact); +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ -static CYTHON_INLINE int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj, - __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); -static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); +/* BufferGetAndValidate.proto */ +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ + ((obj == Py_None || obj == NULL) ?\ + (__Pyx_ZeroBuffer(buf), 0) :\ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; +static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + /* GetModuleGlobalName.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON @@ -1151,39 +1336,39 @@ static void __Pyx_RaiseBufferIndexError(int axis); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET(); +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif -/* BufferFallbackError.proto */ -static void __Pyx_RaiseBufferFallbackError(void); - -#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) -/* PyIntBinop.proto */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace); -#else -#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\ - (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) -#endif - /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ @@ -1202,10 +1387,29 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* BufferFallbackError.proto */ +static void __Pyx_RaiseBufferFallbackError(void); + +#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + /* SliceObject.proto */ #define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)\ __Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound) @@ -1220,43 +1424,15 @@ static CYTHON_INLINE int __Pyx_PyObject_SetSlice( __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) -static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, int wraparound, int boundscheck); -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* DictGetItem.proto */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { - PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) - PyErr_SetObject(PyExc_KeyError, args); - Py_XDECREF(args); - } - return NULL; - } - Py_INCREF(value); - return value; -} -#else - #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); - /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) @@ -1284,11 +1460,29 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto +#define __PYX_HAVE_RT_ImportType_proto +enum __Pyx_ImportType_CheckSize { + __Pyx_ImportType_CheckSize_Error = 0, + __Pyx_ImportType_CheckSize_Warn = 1, + __Pyx_ImportType_CheckSize_Ignore = 2 +}; +static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +#endif + /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ -static int __Pyx_CLineForTraceback(int c_line); +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif /* CodeObjectCache.proto */ typedef struct { @@ -1332,18 +1526,10 @@ typedef struct { #endif -/* None.proto */ -static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0}; -static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1}; - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif /* RealImag.proto */ #if CYTHON_CCOMPLEX @@ -1444,37 +1630,38 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); #endif /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); -/* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); -/* PyIdentifierFromString.proto */ -#if !defined(__Pyx_PyIdentifier_FromString) -#if PY_MAJOR_VERSION < 3 - #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else - #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) -#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) -/* ModuleImport.proto */ -static PyObject *__Pyx_ImportModule(const char *name); - -/* TypeImport.proto */ -static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); @@ -1497,7 +1684,7 @@ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython.ref' */ -/* Module declarations from 'libc.stdlib' */ +/* Module declarations from 'cpython.mem' */ /* Module declarations from 'numpy' */ @@ -1506,19 +1693,27 @@ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_generic = 0; +static PyTypeObject *__pyx_ptype_5numpy_number = 0; +static PyTypeObject *__pyx_ptype_5numpy_integer = 0; +static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; +static PyTypeObject *__pyx_ptype_5numpy_floating = 0; +static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; +static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; +static PyTypeObject *__pyx_ptype_5numpy_character = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; -static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ /* Module declarations from 'utils.box_overlaps' */ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5utils_12box_overlaps_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_5utils_12box_overlaps_DTYPE_t), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "utils.box_overlaps" +extern int __pyx_module_is_main_utils__box_overlaps; int __pyx_module_is_main_utils__box_overlaps = 0; /* Implementation of 'utils.box_overlaps' */ static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin_ValueError; -static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_K[] = "K"; static const char __pyx_k_M[] = "M"; @@ -1540,6 +1735,7 @@ static const char __pyx_k_det[] = "det"; static const char __pyx_k_bit2[] = "bit2"; static const char __pyx_k_det2[] = "det2"; static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_DTYPE[] = "DTYPE"; static const char __pyx_k_boxes[] = "boxes"; @@ -1558,34 +1754,21 @@ static const char __pyx_k_dets_all[] = "dets_all"; static const char __pyx_k_intersec[] = "intersec"; static const char __pyx_k_overlaps[] = "overlaps"; static const char __pyx_k_acc_score[] = "acc_score"; -static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_dets_voted[] = "dets_voted"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_query_boxes[] = "query_boxes"; -static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_bbox_overlaps[] = "bbox_overlaps"; static const char __pyx_k_bbox_intersections[] = "bbox_intersections"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_utils_box_overlaps[] = "utils.box_overlaps"; static const char __pyx_k_utils_box_overlaps_pyx[] = "utils/box_overlaps.pyx"; -static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; -static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; -static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; -static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; -static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; -static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; static PyObject *__pyx_n_s_DTYPE; -static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; -static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_n_s_K; static PyObject *__pyx_n_s_M; static PyObject *__pyx_n_s_N; -static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; -static PyObject *__pyx_n_s_RuntimeError; -static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_acc_box; static PyObject *__pyx_n_s_acc_score; static PyObject *__pyx_n_s_bbox_intersections; @@ -1615,8 +1798,7 @@ static PyObject *__pyx_n_s_k; static PyObject *__pyx_n_s_m; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_n; -static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; -static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; @@ -1628,38 +1810,27 @@ static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_thresh; static PyObject *__pyx_n_s_ua; -static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; static PyObject *__pyx_n_s_utils_box_overlaps; static PyObject *__pyx_kp_s_utils_box_overlaps_pyx; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes); /* proto */ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes); /* proto */ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets_NMS, PyArrayObject *__pyx_v_dets_all); /* proto */ -static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_4; static PyObject *__pyx_slice_; static PyObject *__pyx_slice__3; -static PyObject *__pyx_slice__4; -static PyObject *__pyx_slice__5; static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; -static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; -static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; -static PyObject *__pyx_tuple__11; -static PyObject *__pyx_tuple__12; -static PyObject *__pyx_tuple__13; -static PyObject *__pyx_tuple__14; -static PyObject *__pyx_tuple__15; -static PyObject *__pyx_tuple__17; -static PyObject *__pyx_tuple__19; -static PyObject *__pyx_codeobj__16; -static PyObject *__pyx_codeobj__18; -static PyObject *__pyx_codeobj__20; +static PyObject *__pyx_codeobj__7; +static PyObject *__pyx_codeobj__9; +static PyObject *__pyx_codeobj__11; +/* Late includes */ /* "utils/box_overlaps.pyx":17 * @@ -1672,10 +1843,13 @@ static PyObject *__pyx_codeobj__20; /* Python wrapper */ static PyObject *__pyx_pw_5utils_12box_overlaps_1bbox_overlaps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5utils_12box_overlaps_bbox_overlaps[] = "\n Parameters\n ----------\n boxes: (N, 4) ndarray of float\n query_boxes: (K, 4) ndarray of float\n Returns\n -------\n overlaps: (N, K) ndarray of overlap between boxes and query_boxes\n "; -static PyMethodDef __pyx_mdef_5utils_12box_overlaps_1bbox_overlaps = {"bbox_overlaps", (PyCFunction)__pyx_pw_5utils_12box_overlaps_1bbox_overlaps, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5utils_12box_overlaps_bbox_overlaps}; +static PyMethodDef __pyx_mdef_5utils_12box_overlaps_1bbox_overlaps = {"bbox_overlaps", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5utils_12box_overlaps_1bbox_overlaps, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5utils_12box_overlaps_bbox_overlaps}; static PyObject *__pyx_pw_5utils_12box_overlaps_1bbox_overlaps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyArrayObject *__pyx_v_boxes = 0; PyArrayObject *__pyx_v_query_boxes = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("bbox_overlaps (wrapper)", 0); @@ -1696,11 +1870,11 @@ static PyObject *__pyx_pw_5utils_12box_overlaps_1bbox_overlaps(PyObject *__pyx_s kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: - if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("bbox_overlaps", 1, 2, 2, 1); __PYX_ERR(0, 17, __pyx_L3_error) } @@ -1763,48 +1937,27 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb PyArrayObject *__pyx_t_5 = NULL; unsigned int __pyx_t_6; unsigned int __pyx_t_7; - size_t __pyx_t_8; - Py_ssize_t __pyx_t_9; - int __pyx_t_10; - size_t __pyx_t_11; - Py_ssize_t __pyx_t_12; - size_t __pyx_t_13; - Py_ssize_t __pyx_t_14; - size_t __pyx_t_15; - Py_ssize_t __pyx_t_16; - unsigned int __pyx_t_17; + unsigned int __pyx_t_8; + size_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + size_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + size_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + size_t __pyx_t_16; + Py_ssize_t __pyx_t_17; unsigned int __pyx_t_18; - size_t __pyx_t_19; - Py_ssize_t __pyx_t_20; + unsigned int __pyx_t_19; + unsigned int __pyx_t_20; __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_21; - size_t __pyx_t_22; - Py_ssize_t __pyx_t_23; + __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_22; + __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_23; __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_24; - __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_25; - size_t __pyx_t_26; - Py_ssize_t __pyx_t_27; - size_t __pyx_t_28; - Py_ssize_t __pyx_t_29; - __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_30; - int __pyx_t_31; - size_t __pyx_t_32; - Py_ssize_t __pyx_t_33; - size_t __pyx_t_34; - Py_ssize_t __pyx_t_35; - size_t __pyx_t_36; - Py_ssize_t __pyx_t_37; - size_t __pyx_t_38; - Py_ssize_t __pyx_t_39; - size_t __pyx_t_40; - Py_ssize_t __pyx_t_41; - size_t __pyx_t_42; - Py_ssize_t __pyx_t_43; - size_t __pyx_t_44; - Py_ssize_t __pyx_t_45; - size_t __pyx_t_46; - Py_ssize_t __pyx_t_47; - size_t __pyx_t_48; - size_t __pyx_t_49; + int __pyx_t_25; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bbox_overlaps", 0); __pyx_pybuffer_overlaps.pybuffer.buf = NULL; __pyx_pybuffer_overlaps.refcount = 0; @@ -1854,7 +2007,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * cdef DTYPE_t iw, ih, box_area * cdef DTYPE_t ua */ - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -1876,9 +2029,9 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -1909,8 +2062,9 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * */ __pyx_t_6 = __pyx_v_K; - for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { - __pyx_v_k = __pyx_t_7; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_v_k = __pyx_t_8; /* "utils/box_overlaps.pyx":37 * for k in range(K): @@ -1919,28 +2073,28 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * (query_boxes[k, 3] - query_boxes[k, 1] + 1) * ) */ - __pyx_t_8 = __pyx_v_k; - __pyx_t_9 = 2; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_8 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_9 < 0) { - __pyx_t_9 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_9 = __pyx_v_k; + __pyx_t_10 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_9 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 37, __pyx_L1_error) } - __pyx_t_11 = __pyx_v_k; - __pyx_t_12 = 0; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_11 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_12 < 0) { - __pyx_t_12 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_12 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_12 = __pyx_v_k; + __pyx_t_13 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_12 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_13 < 0) { + __pyx_t_13 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_13 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 37, __pyx_L1_error) } @@ -1951,28 +2105,28 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * ) * for n in range(N): */ - __pyx_t_13 = __pyx_v_k; - __pyx_t_14 = 3; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_13 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_14 < 0) { - __pyx_t_14 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_14 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_14 = __pyx_v_k; + __pyx_t_15 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_14 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 38, __pyx_L1_error) } - __pyx_t_15 = __pyx_v_k; - __pyx_t_16 = 1; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_16 < 0) { - __pyx_t_16 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_16 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 38, __pyx_L1_error) } @@ -1983,7 +2137,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * (query_boxes[k, 3] - query_boxes[k, 1] + 1) * ) */ - __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0)); + __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_10, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0)); /* "utils/box_overlaps.pyx":40 * (query_boxes[k, 3] - query_boxes[k, 1] + 1) @@ -1992,9 +2146,10 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * iw = ( * min(boxes[n, 2], query_boxes[k, 2]) - */ - __pyx_t_17 = __pyx_v_N; - for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) { - __pyx_v_n = __pyx_t_18; + __pyx_t_18 = __pyx_v_N; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { + __pyx_v_n = __pyx_t_20; /* "utils/box_overlaps.pyx":42 * for n in range(N): @@ -2003,36 +2158,36 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * max(boxes[n, 0], query_boxes[k, 0]) + 1 * ) */ - __pyx_t_19 = __pyx_v_k; - __pyx_t_20 = 2; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_19 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_20 < 0) { - __pyx_t_20 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_20 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 42, __pyx_L1_error) } - __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); - __pyx_t_22 = __pyx_v_n; - __pyx_t_23 = 2; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_22 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_23 < 0) { - __pyx_t_23 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_23 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 42, __pyx_L1_error) } - __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_boxes.diminfo[1].strides)); - if (((__pyx_t_21 < __pyx_t_24) != 0)) { - __pyx_t_25 = __pyx_t_21; + __pyx_t_22 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_21 < __pyx_t_22) != 0)) { + __pyx_t_23 = __pyx_t_21; } else { - __pyx_t_25 = __pyx_t_24; + __pyx_t_23 = __pyx_t_22; } /* "utils/box_overlaps.pyx":43 @@ -2042,36 +2197,36 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * ) * if iw > 0: */ - __pyx_t_26 = __pyx_v_k; - __pyx_t_27 = 0; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_26 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_27 < 0) { - __pyx_t_27 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_27 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 43, __pyx_L1_error) } - __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); - __pyx_t_28 = __pyx_v_n; - __pyx_t_29 = 0; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_29 < 0) { - __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_29 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 43, __pyx_L1_error) } - __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[1].strides)); - if (((__pyx_t_21 > __pyx_t_24) != 0)) { - __pyx_t_30 = __pyx_t_21; + __pyx_t_22 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_21 > __pyx_t_22) != 0)) { + __pyx_t_24 = __pyx_t_21; } else { - __pyx_t_30 = __pyx_t_24; + __pyx_t_24 = __pyx_t_22; } /* "utils/box_overlaps.pyx":42 @@ -2081,7 +2236,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * max(boxes[n, 0], query_boxes[k, 0]) + 1 * ) */ - __pyx_v_iw = ((__pyx_t_25 - __pyx_t_30) + 1.0); + __pyx_v_iw = ((__pyx_t_23 - __pyx_t_24) + 1.0); /* "utils/box_overlaps.pyx":45 * max(boxes[n, 0], query_boxes[k, 0]) + 1 @@ -2090,8 +2245,8 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * ih = ( * min(boxes[n, 3], query_boxes[k, 3]) - */ - __pyx_t_31 = ((__pyx_v_iw > 0.0) != 0); - if (__pyx_t_31) { + __pyx_t_25 = ((__pyx_v_iw > 0.0) != 0); + if (__pyx_t_25) { /* "utils/box_overlaps.pyx":47 * if iw > 0: @@ -2100,36 +2255,36 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * max(boxes[n, 1], query_boxes[k, 1]) + 1 * ) */ - __pyx_t_32 = __pyx_v_k; - __pyx_t_33 = 3; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_32 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_33 < 0) { - __pyx_t_33 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_33 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 47, __pyx_L1_error) } - __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_33, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); - __pyx_t_34 = __pyx_v_n; - __pyx_t_35 = 3; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_35 < 0) { - __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_35 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 47, __pyx_L1_error) } - __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[1].strides)); - if (((__pyx_t_30 < __pyx_t_25) != 0)) { - __pyx_t_21 = __pyx_t_30; + __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_24 < __pyx_t_23) != 0)) { + __pyx_t_21 = __pyx_t_24; } else { - __pyx_t_21 = __pyx_t_25; + __pyx_t_21 = __pyx_t_23; } /* "utils/box_overlaps.pyx":48 @@ -2139,36 +2294,36 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * ) * if ih > 0: */ - __pyx_t_36 = __pyx_v_k; - __pyx_t_37 = 1; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_37 < 0) { - __pyx_t_37 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_37 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 48, __pyx_L1_error) } - __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); - __pyx_t_38 = __pyx_v_n; - __pyx_t_39 = 1; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_39 < 0) { - __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_39 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 48, __pyx_L1_error) } - __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[1].strides)); - if (((__pyx_t_30 > __pyx_t_25) != 0)) { - __pyx_t_24 = __pyx_t_30; + __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_24 > __pyx_t_23) != 0)) { + __pyx_t_22 = __pyx_t_24; } else { - __pyx_t_24 = __pyx_t_25; + __pyx_t_22 = __pyx_t_23; } /* "utils/box_overlaps.pyx":47 @@ -2178,7 +2333,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * max(boxes[n, 1], query_boxes[k, 1]) + 1 * ) */ - __pyx_v_ih = ((__pyx_t_21 - __pyx_t_24) + 1.0); + __pyx_v_ih = ((__pyx_t_21 - __pyx_t_22) + 1.0); /* "utils/box_overlaps.pyx":50 * max(boxes[n, 1], query_boxes[k, 1]) + 1 @@ -2187,8 +2342,8 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * ua = float( * (boxes[n, 2] - boxes[n, 0] + 1) * */ - __pyx_t_31 = ((__pyx_v_ih > 0.0) != 0); - if (__pyx_t_31) { + __pyx_t_25 = ((__pyx_v_ih > 0.0) != 0); + if (__pyx_t_25) { /* "utils/box_overlaps.pyx":52 * if ih > 0: @@ -2197,28 +2352,28 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * (boxes[n, 3] - boxes[n, 1] + 1) + * box_area - iw * ih */ - __pyx_t_40 = __pyx_v_n; - __pyx_t_41 = 2; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_41 < 0) { - __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_41 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 52, __pyx_L1_error) } - __pyx_t_42 = __pyx_v_n; - __pyx_t_43 = 0; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_42 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_43 < 0) { - __pyx_t_43 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_43 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_43 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_14 = __pyx_v_n; + __pyx_t_15 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_14 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 52, __pyx_L1_error) } @@ -2229,28 +2384,28 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * box_area - iw * ih * ) */ - __pyx_t_44 = __pyx_v_n; - __pyx_t_45 = 3; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_44 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_45 < 0) { - __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_45 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_12 = __pyx_v_n; + __pyx_t_13 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_12 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_13 < 0) { + __pyx_t_13 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_13 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 53, __pyx_L1_error) } - __pyx_t_46 = __pyx_v_n; - __pyx_t_47 = 1; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_46 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_47 < 0) { - __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_47 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_9 = __pyx_v_n; + __pyx_t_10 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_9 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 53, __pyx_L1_error) } @@ -2261,7 +2416,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * (boxes[n, 2] - boxes[n, 0] + 1) * * (boxes[n, 3] - boxes[n, 1] + 1) + */ - __pyx_v_ua = ((double)((((((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_42, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_43, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_44, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0)) + __pyx_v_box_area) - (__pyx_v_iw * __pyx_v_ih))); + __pyx_v_ua = ((double)((((((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_10, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0)) + __pyx_v_box_area) - (__pyx_v_iw * __pyx_v_ih))); /* "utils/box_overlaps.pyx":56 * box_area - iw * ih @@ -2270,21 +2425,21 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb * return overlaps * */ - __pyx_t_24 = (__pyx_v_iw * __pyx_v_ih); + __pyx_t_22 = (__pyx_v_iw * __pyx_v_ih); if (unlikely(__pyx_v_ua == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 56, __pyx_L1_error) } - __pyx_t_48 = __pyx_v_n; - __pyx_t_49 = __pyx_v_k; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_48 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_49 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_9 = __pyx_v_n; + __pyx_t_12 = __pyx_v_k; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_9 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_12 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 56, __pyx_L1_error) } - *__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf, __pyx_t_48, __pyx_pybuffernd_overlaps.diminfo[0].strides, __pyx_t_49, __pyx_pybuffernd_overlaps.diminfo[1].strides) = (__pyx_t_24 / __pyx_v_ua); + *__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_overlaps.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_overlaps.diminfo[1].strides) = (__pyx_t_22 / __pyx_v_ua); /* "utils/box_overlaps.pyx":50 * max(boxes[n, 1], query_boxes[k, 1]) + 1 @@ -2365,10 +2520,13 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_bbox_overlaps(CYTHON_UNUSED PyOb /* Python wrapper */ static PyObject *__pyx_pw_5utils_12box_overlaps_3bbox_intersections(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5utils_12box_overlaps_2bbox_intersections[] = "\n For each query box compute the intersection ratio covered by boxes\n ----------\n Parameters\n ----------\n boxes: (N, 4) ndarray of float\n query_boxes: (K, 4) ndarray of float\n Returns\n -------\n overlaps: (N, K) ndarray of intersec between boxes and query_boxes\n "; -static PyMethodDef __pyx_mdef_5utils_12box_overlaps_3bbox_intersections = {"bbox_intersections", (PyCFunction)__pyx_pw_5utils_12box_overlaps_3bbox_intersections, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5utils_12box_overlaps_2bbox_intersections}; +static PyMethodDef __pyx_mdef_5utils_12box_overlaps_3bbox_intersections = {"bbox_intersections", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5utils_12box_overlaps_3bbox_intersections, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5utils_12box_overlaps_2bbox_intersections}; static PyObject *__pyx_pw_5utils_12box_overlaps_3bbox_intersections(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyArrayObject *__pyx_v_boxes = 0; PyArrayObject *__pyx_v_query_boxes = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("bbox_intersections (wrapper)", 0); @@ -2389,11 +2547,11 @@ static PyObject *__pyx_pw_5utils_12box_overlaps_3bbox_intersections(PyObject *__ kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: - if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_query_boxes)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("bbox_intersections", 1, 2, 2, 1); __PYX_ERR(0, 59, __pyx_L3_error) } @@ -2455,40 +2613,27 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE PyArrayObject *__pyx_t_5 = NULL; unsigned int __pyx_t_6; unsigned int __pyx_t_7; - size_t __pyx_t_8; - Py_ssize_t __pyx_t_9; - int __pyx_t_10; - size_t __pyx_t_11; - Py_ssize_t __pyx_t_12; - size_t __pyx_t_13; - Py_ssize_t __pyx_t_14; - size_t __pyx_t_15; - Py_ssize_t __pyx_t_16; - unsigned int __pyx_t_17; + unsigned int __pyx_t_8; + size_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + size_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + size_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + size_t __pyx_t_16; + Py_ssize_t __pyx_t_17; unsigned int __pyx_t_18; - size_t __pyx_t_19; - Py_ssize_t __pyx_t_20; + unsigned int __pyx_t_19; + unsigned int __pyx_t_20; __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_21; - size_t __pyx_t_22; - Py_ssize_t __pyx_t_23; + __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_22; + __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_23; __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_24; - __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_25; - size_t __pyx_t_26; - Py_ssize_t __pyx_t_27; - size_t __pyx_t_28; - Py_ssize_t __pyx_t_29; - __pyx_t_5utils_12box_overlaps_DTYPE_t __pyx_t_30; - int __pyx_t_31; - size_t __pyx_t_32; - Py_ssize_t __pyx_t_33; - size_t __pyx_t_34; - Py_ssize_t __pyx_t_35; - size_t __pyx_t_36; - Py_ssize_t __pyx_t_37; - size_t __pyx_t_38; - Py_ssize_t __pyx_t_39; - size_t __pyx_t_40; - size_t __pyx_t_41; + int __pyx_t_25; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bbox_intersections", 0); __pyx_pybuffer_intersec.pybuffer.buf = NULL; __pyx_pybuffer_intersec.refcount = 0; @@ -2538,7 +2683,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * cdef DTYPE_t iw, ih, box_area * cdef DTYPE_t ua */ - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -2560,9 +2705,9 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 75, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 75, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 75, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -2593,8 +2738,9 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * */ __pyx_t_6 = __pyx_v_K; - for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { - __pyx_v_k = __pyx_t_7; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_v_k = __pyx_t_8; /* "utils/box_overlaps.pyx":81 * for k in range(K): @@ -2603,28 +2749,28 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * (query_boxes[k, 3] - query_boxes[k, 1] + 1) * ) */ - __pyx_t_8 = __pyx_v_k; - __pyx_t_9 = 2; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_8 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_9 < 0) { - __pyx_t_9 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_9 = __pyx_v_k; + __pyx_t_10 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_9 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 81, __pyx_L1_error) } - __pyx_t_11 = __pyx_v_k; - __pyx_t_12 = 0; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_11 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_12 < 0) { - __pyx_t_12 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_12 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_12 = __pyx_v_k; + __pyx_t_13 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_12 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_13 < 0) { + __pyx_t_13 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_13 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 81, __pyx_L1_error) } @@ -2635,28 +2781,28 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * ) * for n in range(N): */ - __pyx_t_13 = __pyx_v_k; - __pyx_t_14 = 3; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_13 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_14 < 0) { - __pyx_t_14 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_14 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_14 = __pyx_v_k; + __pyx_t_15 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_14 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 82, __pyx_L1_error) } - __pyx_t_15 = __pyx_v_k; - __pyx_t_16 = 1; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_16 < 0) { - __pyx_t_16 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_16 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 82, __pyx_L1_error) } @@ -2667,7 +2813,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * (query_boxes[k, 3] - query_boxes[k, 1] + 1) * ) */ - __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0)); + __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_10, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0)); /* "utils/box_overlaps.pyx":84 * (query_boxes[k, 3] - query_boxes[k, 1] + 1) @@ -2676,9 +2822,10 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * iw = ( * min(boxes[n, 2], query_boxes[k, 2]) - */ - __pyx_t_17 = __pyx_v_N; - for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) { - __pyx_v_n = __pyx_t_18; + __pyx_t_18 = __pyx_v_N; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { + __pyx_v_n = __pyx_t_20; /* "utils/box_overlaps.pyx":86 * for n in range(N): @@ -2687,36 +2834,36 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * max(boxes[n, 0], query_boxes[k, 0]) + 1 * ) */ - __pyx_t_19 = __pyx_v_k; - __pyx_t_20 = 2; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_19 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_20 < 0) { - __pyx_t_20 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_20 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 86, __pyx_L1_error) } - __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); - __pyx_t_22 = __pyx_v_n; - __pyx_t_23 = 2; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_22 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_23 < 0) { - __pyx_t_23 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_23 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 86, __pyx_L1_error) } - __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_boxes.diminfo[1].strides)); - if (((__pyx_t_21 < __pyx_t_24) != 0)) { - __pyx_t_25 = __pyx_t_21; + __pyx_t_22 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_21 < __pyx_t_22) != 0)) { + __pyx_t_23 = __pyx_t_21; } else { - __pyx_t_25 = __pyx_t_24; + __pyx_t_23 = __pyx_t_22; } /* "utils/box_overlaps.pyx":87 @@ -2726,36 +2873,36 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * ) * if iw > 0: */ - __pyx_t_26 = __pyx_v_k; - __pyx_t_27 = 0; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_26 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_27 < 0) { - __pyx_t_27 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_27 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 87, __pyx_L1_error) } - __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); - __pyx_t_28 = __pyx_v_n; - __pyx_t_29 = 0; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_29 < 0) { - __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_29 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_21 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 87, __pyx_L1_error) } - __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[1].strides)); - if (((__pyx_t_21 > __pyx_t_24) != 0)) { - __pyx_t_30 = __pyx_t_21; + __pyx_t_22 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_21 > __pyx_t_22) != 0)) { + __pyx_t_24 = __pyx_t_21; } else { - __pyx_t_30 = __pyx_t_24; + __pyx_t_24 = __pyx_t_22; } /* "utils/box_overlaps.pyx":86 @@ -2765,7 +2912,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * max(boxes[n, 0], query_boxes[k, 0]) + 1 * ) */ - __pyx_v_iw = ((__pyx_t_25 - __pyx_t_30) + 1.0); + __pyx_v_iw = ((__pyx_t_23 - __pyx_t_24) + 1.0); /* "utils/box_overlaps.pyx":89 * max(boxes[n, 0], query_boxes[k, 0]) + 1 @@ -2774,8 +2921,8 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * ih = ( * min(boxes[n, 3], query_boxes[k, 3]) - */ - __pyx_t_31 = ((__pyx_v_iw > 0.0) != 0); - if (__pyx_t_31) { + __pyx_t_25 = ((__pyx_v_iw > 0.0) != 0); + if (__pyx_t_25) { /* "utils/box_overlaps.pyx":91 * if iw > 0: @@ -2784,36 +2931,36 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * max(boxes[n, 1], query_boxes[k, 1]) + 1 * ) */ - __pyx_t_32 = __pyx_v_k; - __pyx_t_33 = 3; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_32 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_33 < 0) { - __pyx_t_33 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_33 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 91, __pyx_L1_error) } - __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_33, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); - __pyx_t_34 = __pyx_v_n; - __pyx_t_35 = 3; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_35 < 0) { - __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_35 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 91, __pyx_L1_error) } - __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[1].strides)); - if (((__pyx_t_30 < __pyx_t_25) != 0)) { - __pyx_t_21 = __pyx_t_30; + __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_24 < __pyx_t_23) != 0)) { + __pyx_t_21 = __pyx_t_24; } else { - __pyx_t_21 = __pyx_t_25; + __pyx_t_21 = __pyx_t_23; } /* "utils/box_overlaps.pyx":92 @@ -2823,36 +2970,36 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * ) * if ih > 0: */ - __pyx_t_36 = __pyx_v_k; - __pyx_t_37 = 1; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_37 < 0) { - __pyx_t_37 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_37 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 92, __pyx_L1_error) } - __pyx_t_30 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); - __pyx_t_38 = __pyx_v_n; - __pyx_t_39 = 1; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_10 = 0; - if (__pyx_t_39 < 0) { - __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[1].shape; - if (unlikely(__pyx_t_39 < 0)) __pyx_t_10 = 1; - } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_24 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_16 = __pyx_v_n; + __pyx_t_17 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 92, __pyx_L1_error) } - __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[1].strides)); - if (((__pyx_t_30 > __pyx_t_25) != 0)) { - __pyx_t_24 = __pyx_t_30; + __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_24 > __pyx_t_23) != 0)) { + __pyx_t_22 = __pyx_t_24; } else { - __pyx_t_24 = __pyx_t_25; + __pyx_t_22 = __pyx_t_23; } /* "utils/box_overlaps.pyx":91 @@ -2862,7 +3009,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * max(boxes[n, 1], query_boxes[k, 1]) + 1 * ) */ - __pyx_v_ih = ((__pyx_t_21 - __pyx_t_24) + 1.0); + __pyx_v_ih = ((__pyx_t_21 - __pyx_t_22) + 1.0); /* "utils/box_overlaps.pyx":94 * max(boxes[n, 1], query_boxes[k, 1]) + 1 @@ -2871,8 +3018,8 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * intersec[n, k] = iw * ih / box_area * return intersec */ - __pyx_t_31 = ((__pyx_v_ih > 0.0) != 0); - if (__pyx_t_31) { + __pyx_t_25 = ((__pyx_v_ih > 0.0) != 0); + if (__pyx_t_25) { /* "utils/box_overlaps.pyx":95 * ) @@ -2881,21 +3028,21 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE * return intersec * */ - __pyx_t_24 = (__pyx_v_iw * __pyx_v_ih); + __pyx_t_22 = (__pyx_v_iw * __pyx_v_ih); if (unlikely(__pyx_v_box_area == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 95, __pyx_L1_error) } - __pyx_t_40 = __pyx_v_n; - __pyx_t_41 = __pyx_v_k; - __pyx_t_10 = -1; - if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_intersec.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_41 >= (size_t)__pyx_pybuffernd_intersec.diminfo[1].shape)) __pyx_t_10 = 1; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_16 = __pyx_v_n; + __pyx_t_14 = __pyx_v_k; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_intersec.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_14 >= (size_t)__pyx_pybuffernd_intersec.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 95, __pyx_L1_error) } - *__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_intersec.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_intersec.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_intersec.diminfo[1].strides) = (__pyx_t_24 / __pyx_v_box_area); + *__Pyx_BufPtrStrided2d(__pyx_t_5utils_12box_overlaps_DTYPE_t *, __pyx_pybuffernd_intersec.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_intersec.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_intersec.diminfo[1].strides) = (__pyx_t_22 / __pyx_v_box_area); /* "utils/box_overlaps.pyx":94 * max(boxes[n, 1], query_boxes[k, 1]) + 1 @@ -2975,10 +3122,13 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_2bbox_intersections(CYTHON_UNUSE /* Python wrapper */ static PyObject *__pyx_pw_5utils_12box_overlaps_5box_vote(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_5utils_12box_overlaps_5box_vote = {"box_vote", (PyCFunction)__pyx_pw_5utils_12box_overlaps_5box_vote, METH_VARARGS|METH_KEYWORDS, 0}; +static PyMethodDef __pyx_mdef_5utils_12box_overlaps_5box_vote = {"box_vote", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5utils_12box_overlaps_5box_vote, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_5utils_12box_overlaps_5box_vote(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyArrayObject *__pyx_v_dets_NMS = 0; PyArrayObject *__pyx_v_dets_all = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("box_vote (wrapper)", 0); @@ -2999,11 +3149,11 @@ static PyObject *__pyx_pw_5utils_12box_overlaps_5box_vote(PyObject *__pyx_self, kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: - if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dets_NMS)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dets_NMS)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dets_all)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dets_all)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("box_vote", 1, 2, 2, 1); __PYX_ERR(0, 99, __pyx_L3_error) } @@ -3082,39 +3232,33 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject PyArrayObject *__pyx_t_6 = NULL; unsigned int __pyx_t_7; unsigned int __pyx_t_8; - PyArrayObject *__pyx_t_9 = NULL; - int __pyx_t_10; - PyObject *__pyx_t_11 = NULL; + unsigned int __pyx_t_9; + PyArrayObject *__pyx_t_10 = NULL; + int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; - PyArrayObject *__pyx_t_14 = NULL; - unsigned int __pyx_t_15; + PyObject *__pyx_t_14 = NULL; + PyArrayObject *__pyx_t_15 = NULL; unsigned int __pyx_t_16; - PyArrayObject *__pyx_t_17 = NULL; - Py_ssize_t __pyx_t_18; - float __pyx_t_19; + unsigned int __pyx_t_17; + unsigned int __pyx_t_18; + PyArrayObject *__pyx_t_19 = NULL; Py_ssize_t __pyx_t_20; float __pyx_t_21; float __pyx_t_22; - Py_ssize_t __pyx_t_23; - Py_ssize_t __pyx_t_24; - Py_ssize_t __pyx_t_25; + float __pyx_t_23; + int __pyx_t_24; + int __pyx_t_25; Py_ssize_t __pyx_t_26; Py_ssize_t __pyx_t_27; Py_ssize_t __pyx_t_28; - int __pyx_t_29; - int __pyx_t_30; + Py_ssize_t __pyx_t_29; + Py_ssize_t __pyx_t_30; Py_ssize_t __pyx_t_31; Py_ssize_t __pyx_t_32; - Py_ssize_t __pyx_t_33; - Py_ssize_t __pyx_t_34; - Py_ssize_t __pyx_t_35; - Py_ssize_t __pyx_t_36; - Py_ssize_t __pyx_t_37; - Py_ssize_t __pyx_t_38; - Py_ssize_t __pyx_t_39; - Py_ssize_t __pyx_t_40; - Py_ssize_t __pyx_t_41; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("box_vote", 0); __pyx_pybuffer_dets_voted.pybuffer.buf = NULL; __pyx_pybuffer_dets_voted.refcount = 0; @@ -3158,7 +3302,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * cdef unsigned int N = dets_NMS.shape[0] * cdef unsigned int M = dets_all.shape[0] */ - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -3180,9 +3324,9 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); @@ -3243,8 +3387,9 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * acc_box = np.zeros((4), dtype=np.float32) */ __pyx_t_7 = __pyx_v_N; - for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { - __pyx_v_i = __pyx_t_8; + __pyx_t_8 = __pyx_t_7; + for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) { + __pyx_v_i = __pyx_t_9; /* "utils/box_overlaps.pyx":117 * @@ -3263,28 +3408,29 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject __Pyx_GIVEREF(__pyx_slice_); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_slice_); __pyx_t_5 = 0; - __pyx_t_5 = PyObject_GetItem(((PyObject *)__pyx_v_dets_NMS), __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 117, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets_NMS), __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 117, __pyx_L1_error) - __pyx_t_9 = ((PyArrayObject *)__pyx_t_5); + __pyx_t_10 = ((PyArrayObject *)__pyx_t_5); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_det.rcbuffer->pybuffer); - __pyx_t_10 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_det.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); - if (unlikely(__pyx_t_10 < 0)) { - PyErr_Fetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); + __pyx_t_11 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_det.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_11 < 0)) { + PyErr_Fetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_det.rcbuffer->pybuffer, (PyObject*)__pyx_v_det, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_13); + Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_14); __Pyx_RaiseBufferFallbackError(); } else { - PyErr_Restore(__pyx_t_11, __pyx_t_12, __pyx_t_13); + PyErr_Restore(__pyx_t_12, __pyx_t_13, __pyx_t_14); } + __pyx_t_12 = __pyx_t_13 = __pyx_t_14 = 0; } __pyx_pybuffernd_det.diminfo[0].strides = __pyx_pybuffernd_det.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_det.diminfo[0].shape = __pyx_pybuffernd_det.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 117, __pyx_L1_error) + if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 117, __pyx_L1_error) } - __pyx_t_9 = 0; + __pyx_t_10 = 0; __Pyx_XDECREF_SET(__pyx_v_det, ((PyArrayObject *)__pyx_t_5)); __pyx_t_5 = 0; @@ -3295,14 +3441,14 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * acc_score = 0.0 * */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float32); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -3314,24 +3460,25 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 118, __pyx_L1_error) - __pyx_t_14 = ((PyArrayObject *)__pyx_t_2); + __pyx_t_15 = ((PyArrayObject *)__pyx_t_2); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acc_box.rcbuffer->pybuffer); - __pyx_t_10 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acc_box.rcbuffer->pybuffer, (PyObject*)__pyx_t_14, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); - if (unlikely(__pyx_t_10 < 0)) { - PyErr_Fetch(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11); + __pyx_t_11 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acc_box.rcbuffer->pybuffer, (PyObject*)__pyx_t_15, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_11 < 0)) { + PyErr_Fetch(&__pyx_t_14, &__pyx_t_13, &__pyx_t_12); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acc_box.rcbuffer->pybuffer, (PyObject*)__pyx_v_acc_box, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_11); + Py_XDECREF(__pyx_t_14); Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_12); __Pyx_RaiseBufferFallbackError(); } else { - PyErr_Restore(__pyx_t_13, __pyx_t_12, __pyx_t_11); + PyErr_Restore(__pyx_t_14, __pyx_t_13, __pyx_t_12); } + __pyx_t_14 = __pyx_t_13 = __pyx_t_12 = 0; } __pyx_pybuffernd_acc_box.diminfo[0].strides = __pyx_pybuffernd_acc_box.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acc_box.diminfo[0].shape = __pyx_pybuffernd_acc_box.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 118, __pyx_L1_error) + if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 118, __pyx_L1_error) } - __pyx_t_14 = 0; + __pyx_t_15 = 0; __Pyx_XDECREF_SET(__pyx_v_acc_box, ((PyArrayObject *)__pyx_t_2)); __pyx_t_2 = 0; @@ -3351,9 +3498,10 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * det2 = dets_all[m, :] * */ - __pyx_t_15 = __pyx_v_M; - for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { - __pyx_v_m = __pyx_t_16; + __pyx_t_16 = __pyx_v_M; + __pyx_t_17 = __pyx_t_16; + for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) { + __pyx_v_m = __pyx_t_18; /* "utils/box_overlaps.pyx":122 * @@ -3368,32 +3516,33 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); - __Pyx_INCREF(__pyx_slice__3); - __Pyx_GIVEREF(__pyx_slice__3); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_slice__3); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_slice_); __pyx_t_2 = 0; - __pyx_t_2 = PyObject_GetItem(((PyObject *)__pyx_v_dets_all), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets_all), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 122, __pyx_L1_error) - __pyx_t_17 = ((PyArrayObject *)__pyx_t_2); + __pyx_t_19 = ((PyArrayObject *)__pyx_t_2); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_det2.rcbuffer->pybuffer); - __pyx_t_10 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_det2.rcbuffer->pybuffer, (PyObject*)__pyx_t_17, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); - if (unlikely(__pyx_t_10 < 0)) { - PyErr_Fetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); + __pyx_t_11 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_det2.rcbuffer->pybuffer, (PyObject*)__pyx_t_19, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_11 < 0)) { + PyErr_Fetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_det2.rcbuffer->pybuffer, (PyObject*)__pyx_v_det2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_13); + Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_14); __Pyx_RaiseBufferFallbackError(); } else { - PyErr_Restore(__pyx_t_11, __pyx_t_12, __pyx_t_13); + PyErr_Restore(__pyx_t_12, __pyx_t_13, __pyx_t_14); } + __pyx_t_12 = __pyx_t_13 = __pyx_t_14 = 0; } __pyx_pybuffernd_det2.diminfo[0].strides = __pyx_pybuffernd_det2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_det2.diminfo[0].shape = __pyx_pybuffernd_det2.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 122, __pyx_L1_error) + if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 122, __pyx_L1_error) } - __pyx_t_17 = 0; + __pyx_t_19 = 0; __Pyx_XDECREF_SET(__pyx_v_det2, ((PyArrayObject *)__pyx_t_2)); __pyx_t_2 = 0; @@ -3404,34 +3553,34 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * bi1 = max(det[1], det2[1]) * bi2 = min(det[2], det2[2]) */ - __pyx_t_18 = 0; - __pyx_t_10 = -1; - if (__pyx_t_18 < 0) { - __pyx_t_18 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_18 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_20 = 0; + __pyx_t_11 = -1; + if (__pyx_t_20 < 0) { + __pyx_t_20 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 124, __pyx_L1_error) } - __pyx_t_19 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_det2.diminfo[0].strides)); + __pyx_t_21 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det2.diminfo[0].strides)); __pyx_t_20 = 0; - __pyx_t_10 = -1; + __pyx_t_11 = -1; if (__pyx_t_20 < 0) { __pyx_t_20 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_20 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 124, __pyx_L1_error) } - __pyx_t_21 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det.diminfo[0].strides)); - if (((__pyx_t_19 > __pyx_t_21) != 0)) { - __pyx_t_22 = __pyx_t_19; + __pyx_t_22 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det.diminfo[0].strides)); + if (((__pyx_t_21 > __pyx_t_22) != 0)) { + __pyx_t_23 = __pyx_t_21; } else { - __pyx_t_22 = __pyx_t_21; + __pyx_t_23 = __pyx_t_22; } - __pyx_v_bi0 = __pyx_t_22; + __pyx_v_bi0 = __pyx_t_23; /* "utils/box_overlaps.pyx":125 * @@ -3440,34 +3589,34 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * bi2 = min(det[2], det2[2]) * bi3 = min(det[3], det2[3]) */ - __pyx_t_23 = 1; - __pyx_t_10 = -1; - if (__pyx_t_23 < 0) { - __pyx_t_23 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_23 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_20 = 1; + __pyx_t_11 = -1; + if (__pyx_t_20 < 0) { + __pyx_t_20 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 125, __pyx_L1_error) } - __pyx_t_22 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_det2.diminfo[0].strides)); - __pyx_t_24 = 1; - __pyx_t_10 = -1; - if (__pyx_t_24 < 0) { - __pyx_t_24 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_24 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_24 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_23 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det2.diminfo[0].strides)); + __pyx_t_20 = 1; + __pyx_t_11 = -1; + if (__pyx_t_20 < 0) { + __pyx_t_20 += __pyx_pybuffernd_det.diminfo[0].shape; + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 125, __pyx_L1_error) } - __pyx_t_19 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_det.diminfo[0].strides)); - if (((__pyx_t_22 > __pyx_t_19) != 0)) { - __pyx_t_21 = __pyx_t_22; + __pyx_t_21 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det.diminfo[0].strides)); + if (((__pyx_t_23 > __pyx_t_21) != 0)) { + __pyx_t_22 = __pyx_t_23; } else { - __pyx_t_21 = __pyx_t_19; + __pyx_t_22 = __pyx_t_21; } - __pyx_v_bi1 = __pyx_t_21; + __pyx_v_bi1 = __pyx_t_22; /* "utils/box_overlaps.pyx":126 * bi0 = max(det[0], det2[0]) @@ -3476,34 +3625,34 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * bi3 = min(det[3], det2[3]) * */ - __pyx_t_25 = 2; - __pyx_t_10 = -1; - if (__pyx_t_25 < 0) { - __pyx_t_25 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_25 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_20 = 2; + __pyx_t_11 = -1; + if (__pyx_t_20 < 0) { + __pyx_t_20 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 126, __pyx_L1_error) } - __pyx_t_21 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_25, __pyx_pybuffernd_det2.diminfo[0].strides)); - __pyx_t_26 = 2; - __pyx_t_10 = -1; - if (__pyx_t_26 < 0) { - __pyx_t_26 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_26 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_26 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_22 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det2.diminfo[0].strides)); + __pyx_t_20 = 2; + __pyx_t_11 = -1; + if (__pyx_t_20 < 0) { + __pyx_t_20 += __pyx_pybuffernd_det.diminfo[0].shape; + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 126, __pyx_L1_error) } - __pyx_t_22 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_det.diminfo[0].strides)); - if (((__pyx_t_21 < __pyx_t_22) != 0)) { - __pyx_t_19 = __pyx_t_21; + __pyx_t_23 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det.diminfo[0].strides)); + if (((__pyx_t_22 < __pyx_t_23) != 0)) { + __pyx_t_21 = __pyx_t_22; } else { - __pyx_t_19 = __pyx_t_22; + __pyx_t_21 = __pyx_t_23; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_19); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_21); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_bi2, __pyx_t_2); __pyx_t_2 = 0; @@ -3515,34 +3664,34 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * * iw = bi2 - bi0 + 1 */ - __pyx_t_27 = 3; - __pyx_t_10 = -1; - if (__pyx_t_27 < 0) { - __pyx_t_27 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_27 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_20 = 3; + __pyx_t_11 = -1; + if (__pyx_t_20 < 0) { + __pyx_t_20 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 127, __pyx_L1_error) } - __pyx_t_19 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_27, __pyx_pybuffernd_det2.diminfo[0].strides)); - __pyx_t_28 = 3; - __pyx_t_10 = -1; - if (__pyx_t_28 < 0) { - __pyx_t_28 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_28 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_28 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_21 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det2.diminfo[0].strides)); + __pyx_t_20 = 3; + __pyx_t_11 = -1; + if (__pyx_t_20 < 0) { + __pyx_t_20 += __pyx_pybuffernd_det.diminfo[0].shape; + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 127, __pyx_L1_error) } - __pyx_t_21 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_det.diminfo[0].strides)); - if (((__pyx_t_19 < __pyx_t_21) != 0)) { - __pyx_t_22 = __pyx_t_19; + __pyx_t_22 = (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det.diminfo[0].strides)); + if (((__pyx_t_21 < __pyx_t_22) != 0)) { + __pyx_t_23 = __pyx_t_21; } else { - __pyx_t_22 = __pyx_t_21; + __pyx_t_23 = __pyx_t_22; } - __pyx_v_bi3 = __pyx_t_22; + __pyx_v_bi3 = __pyx_t_23; /* "utils/box_overlaps.pyx":129 * bi3 = min(det[3], det2[3]) @@ -3556,12 +3705,12 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject __pyx_t_5 = PyNumber_Subtract(__pyx_v_bi2, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_5, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_5, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_22 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_22 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 129, __pyx_L1_error) + __pyx_t_23 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_23 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 129, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_iw = __pyx_t_22; + __pyx_v_iw = __pyx_t_23; /* "utils/box_overlaps.pyx":130 * @@ -3579,17 +3728,17 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * continue * */ - __pyx_t_30 = ((__pyx_v_iw > 0.0) != 0); - if (__pyx_t_30) { + __pyx_t_25 = ((__pyx_v_iw > 0.0) != 0); + if (__pyx_t_25) { } else { - __pyx_t_29 = __pyx_t_30; + __pyx_t_24 = __pyx_t_25; goto __pyx_L8_bool_binop_done; } - __pyx_t_30 = ((__pyx_v_ih > 0.0) != 0); - __pyx_t_29 = __pyx_t_30; + __pyx_t_25 = ((__pyx_v_ih > 0.0) != 0); + __pyx_t_24 = __pyx_t_25; __pyx_L8_bool_binop_done:; - __pyx_t_30 = ((!__pyx_t_29) != 0); - if (__pyx_t_30) { + __pyx_t_25 = ((!__pyx_t_24) != 0); + if (__pyx_t_25) { /* "utils/box_overlaps.pyx":133 * @@ -3616,87 +3765,87 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * ov = iw * ih / ua * */ - __pyx_t_31 = 2; - __pyx_t_10 = -1; - if (__pyx_t_31 < 0) { - __pyx_t_31 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_31 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_20 = 2; + __pyx_t_11 = -1; + if (__pyx_t_20 < 0) { + __pyx_t_20 += __pyx_pybuffernd_det.diminfo[0].shape; + if (unlikely(__pyx_t_20 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 135, __pyx_L1_error) } - __pyx_t_32 = 0; - __pyx_t_10 = -1; - if (__pyx_t_32 < 0) { - __pyx_t_32 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_32 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_26 = 0; + __pyx_t_11 = -1; + if (__pyx_t_26 < 0) { + __pyx_t_26 += __pyx_pybuffernd_det.diminfo[0].shape; + if (unlikely(__pyx_t_26 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_26 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 135, __pyx_L1_error) } - __pyx_t_33 = 3; - __pyx_t_10 = -1; - if (__pyx_t_33 < 0) { - __pyx_t_33 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_33 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_27 = 3; + __pyx_t_11 = -1; + if (__pyx_t_27 < 0) { + __pyx_t_27 += __pyx_pybuffernd_det.diminfo[0].shape; + if (unlikely(__pyx_t_27 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 135, __pyx_L1_error) } - __pyx_t_34 = 1; - __pyx_t_10 = -1; - if (__pyx_t_34 < 0) { - __pyx_t_34 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_34 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_34 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_28 = 1; + __pyx_t_11 = -1; + if (__pyx_t_28 < 0) { + __pyx_t_28 += __pyx_pybuffernd_det.diminfo[0].shape; + if (unlikely(__pyx_t_28 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_28 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 135, __pyx_L1_error) } - __pyx_t_35 = 2; - __pyx_t_10 = -1; - if (__pyx_t_35 < 0) { - __pyx_t_35 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_35 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_29 = 2; + __pyx_t_11 = -1; + if (__pyx_t_29 < 0) { + __pyx_t_29 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_29 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 135, __pyx_L1_error) } - __pyx_t_36 = 0; - __pyx_t_10 = -1; - if (__pyx_t_36 < 0) { - __pyx_t_36 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_36 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_36 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_30 = 0; + __pyx_t_11 = -1; + if (__pyx_t_30 < 0) { + __pyx_t_30 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_30 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_30 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 135, __pyx_L1_error) } - __pyx_t_37 = 3; - __pyx_t_10 = -1; - if (__pyx_t_37 < 0) { - __pyx_t_37 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_37 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_31 = 3; + __pyx_t_11 = -1; + if (__pyx_t_31 < 0) { + __pyx_t_31 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_31 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 135, __pyx_L1_error) } - __pyx_t_38 = 1; - __pyx_t_10 = -1; - if (__pyx_t_38 < 0) { - __pyx_t_38 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_38 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_38 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_32 = 1; + __pyx_t_11 = -1; + if (__pyx_t_32 < 0) { + __pyx_t_32 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_32 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 135, __pyx_L1_error) } - __pyx_v_ua = ((((((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_31, __pyx_pybuffernd_det.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_det.diminfo[0].strides))) + 1.0) * (((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_33, __pyx_pybuffernd_det.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_det.diminfo[0].strides))) + 1.0)) + ((((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_35, __pyx_pybuffernd_det2.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_det2.diminfo[0].strides))) + 1.0) * (((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_37, __pyx_pybuffernd_det2.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_det2.diminfo[0].strides))) + 1.0))) - (__pyx_v_iw * __pyx_v_ih)); + __pyx_v_ua = ((((((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_det.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_det.diminfo[0].strides))) + 1.0) * (((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_27, __pyx_pybuffernd_det.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_det.diminfo[0].strides))) + 1.0)) + ((((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_29, __pyx_pybuffernd_det2.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_det2.diminfo[0].strides))) + 1.0) * (((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_31, __pyx_pybuffernd_det2.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_det2.diminfo[0].strides))) + 1.0))) - (__pyx_v_iw * __pyx_v_ih)); /* "utils/box_overlaps.pyx":136 * @@ -3705,12 +3854,12 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * * if (ov < thresh): */ - __pyx_t_22 = (__pyx_v_iw * __pyx_v_ih); + __pyx_t_23 = (__pyx_v_iw * __pyx_v_ih); if (unlikely(__pyx_v_ua == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 136, __pyx_L1_error) } - __pyx_t_2 = PyFloat_FromDouble((__pyx_t_22 / __pyx_v_ua)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble((__pyx_t_23 / __pyx_v_ua)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_ov, __pyx_t_2); __pyx_t_2 = 0; @@ -3726,9 +3875,9 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = PyObject_RichCompare(__pyx_v_ov, __pyx_t_2, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_30 < 0)) __PYX_ERR(0, 138, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_25 < 0)) __PYX_ERR(0, 138, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (__pyx_t_30) { + if (__pyx_t_25) { /* "utils/box_overlaps.pyx":139 * @@ -3755,19 +3904,19 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * acc_score += det2[4] * */ - __pyx_t_39 = 4; - __pyx_t_10 = -1; - if (__pyx_t_39 < 0) { - __pyx_t_39 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_39 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_32 = 4; + __pyx_t_11 = -1; + if (__pyx_t_32 < 0) { + __pyx_t_32 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_32 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 141, __pyx_L1_error) } - __pyx_t_5 = PyFloat_FromDouble((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_39, __pyx_pybuffernd_det2.diminfo[0].strides))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 141, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_det2.diminfo[0].strides))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = PyObject_GetItem(((PyObject *)__pyx_v_det2), __pyx_slice__4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_det2), __pyx_slice__3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyNumber_Multiply(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); @@ -3777,24 +3926,25 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 141, __pyx_L1_error) - __pyx_t_14 = ((PyArrayObject *)__pyx_t_2); + __pyx_t_15 = ((PyArrayObject *)__pyx_t_2); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acc_box.rcbuffer->pybuffer); - __pyx_t_10 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acc_box.rcbuffer->pybuffer, (PyObject*)__pyx_t_14, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); - if (unlikely(__pyx_t_10 < 0)) { - PyErr_Fetch(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11); + __pyx_t_11 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acc_box.rcbuffer->pybuffer, (PyObject*)__pyx_t_15, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_11 < 0)) { + PyErr_Fetch(&__pyx_t_14, &__pyx_t_13, &__pyx_t_12); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acc_box.rcbuffer->pybuffer, (PyObject*)__pyx_v_acc_box, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_11); + Py_XDECREF(__pyx_t_14); Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_12); __Pyx_RaiseBufferFallbackError(); } else { - PyErr_Restore(__pyx_t_13, __pyx_t_12, __pyx_t_11); + PyErr_Restore(__pyx_t_14, __pyx_t_13, __pyx_t_12); } + __pyx_t_14 = __pyx_t_13 = __pyx_t_12 = 0; } __pyx_pybuffernd_acc_box.diminfo[0].strides = __pyx_pybuffernd_acc_box.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acc_box.diminfo[0].shape = __pyx_pybuffernd_acc_box.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 141, __pyx_L1_error) + if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 141, __pyx_L1_error) } - __pyx_t_14 = 0; + __pyx_t_15 = 0; __Pyx_DECREF_SET(__pyx_v_acc_box, ((PyArrayObject *)__pyx_t_2)); __pyx_t_2 = 0; @@ -3805,17 +3955,17 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * * dets_voted[i][0:4] = acc_box / acc_score */ - __pyx_t_40 = 4; - __pyx_t_10 = -1; - if (__pyx_t_40 < 0) { - __pyx_t_40 += __pyx_pybuffernd_det2.diminfo[0].shape; - if (unlikely(__pyx_t_40 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_40 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_32 = 4; + __pyx_t_11 = -1; + if (__pyx_t_32 < 0) { + __pyx_t_32 += __pyx_pybuffernd_det2.diminfo[0].shape; + if (unlikely(__pyx_t_32 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_det2.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 142, __pyx_L1_error) } - __pyx_v_acc_score = (__pyx_v_acc_score + (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_det2.diminfo[0].strides))); + __pyx_v_acc_score = (__pyx_v_acc_score + (*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det2.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_det2.diminfo[0].strides))); __pyx_L5_continue:; } @@ -3833,7 +3983,7 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_dets_voted), __pyx_v_i, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_PyObject_SetSlice(__pyx_t_2, __pyx_t_4, 0, 4, NULL, NULL, &__pyx_slice__5, 1, 1, 1) < 0) __PYX_ERR(0, 144, __pyx_L1_error) + if (__Pyx_PyObject_SetSlice(__pyx_t_2, __pyx_t_4, 0, 4, NULL, NULL, &__pyx_slice__3, 1, 1, 1) < 0) __PYX_ERR(0, 144, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -3844,17 +3994,17 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject * * return dets_voted */ - __pyx_t_41 = 4; - __pyx_t_10 = -1; - if (__pyx_t_41 < 0) { - __pyx_t_41 += __pyx_pybuffernd_det.diminfo[0].shape; - if (unlikely(__pyx_t_41 < 0)) __pyx_t_10 = 0; - } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_10 = 0; - if (unlikely(__pyx_t_10 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_10); + __pyx_t_32 = 4; + __pyx_t_11 = -1; + if (__pyx_t_32 < 0) { + __pyx_t_32 += __pyx_pybuffernd_det.diminfo[0].shape; + if (unlikely(__pyx_t_32 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_det.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); __PYX_ERR(0, 145, __pyx_L1_error) } - __pyx_t_4 = PyFloat_FromDouble((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_41, __pyx_pybuffernd_det.diminfo[0].strides))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_det.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_det.diminfo[0].strides))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_dets_voted), __pyx_v_i, unsigned int, 0, __Pyx_PyInt_From_unsigned_int, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -3921,985 +4071,24 @@ static PyObject *__pyx_pf_5utils_12box_overlaps_4box_vote(CYTHON_UNUSED PyObject return __pyx_r; } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":197 - * # experimental exception made for __getbuffer__ and __releasebuffer__ - * # -- the details of this may change. - * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< - * # This implementation of getbuffer is geared towards Cython - * # requirements, and does not yet fullfill the PEP. +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * */ -/* Python wrapper */ -static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_v_copy_shape; - int __pyx_v_i; - int __pyx_v_ndim; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - int __pyx_v_t; - char *__pyx_v_f; - PyArray_Descr *__pyx_v_descr = 0; - int __pyx_v_offset; - int __pyx_v_hasfields; - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - char *__pyx_t_7; - __Pyx_RefNannySetupContext("__getbuffer__", 0); - if (__pyx_v_info != NULL) { - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":203 - * # of flags - * - * if info == NULL: return # <<<<<<<<<<<<<< - * - * cdef int copy_shape, i, ndim - */ - __pyx_t_1 = ((__pyx_v_info == NULL) != 0); - if (__pyx_t_1) { - __pyx_r = 0; - goto __pyx_L0; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":206 - * - * cdef int copy_shape, i, ndim - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * - */ - __pyx_v_endian_detector = 1; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":207 - * cdef int copy_shape, i, ndim - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< - * - * ndim = PyArray_NDIM(self) - */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":209 - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * - * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< - * - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - */ - __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":211 - * ndim = PyArray_NDIM(self) - * - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * copy_shape = 1 - * else: - */ - __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":212 - * - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * copy_shape = 1 # <<<<<<<<<<<<<< - * else: - * copy_shape = 0 - */ - __pyx_v_copy_shape = 1; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":211 - * ndim = PyArray_NDIM(self) - * - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * copy_shape = 1 - * else: - */ - goto __pyx_L4; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":214 - * copy_shape = 1 - * else: - * copy_shape = 0 # <<<<<<<<<<<<<< - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - */ - /*else*/ { - __pyx_v_copy_shape = 0; - } - __pyx_L4:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":216 - * copy_shape = 0 - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") - */ - __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L6_bool_binop_done; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":217 - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< - * raise ValueError(u"ndarray is not C contiguous") - * - */ - __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L6_bool_binop_done:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":216 - * copy_shape = 0 - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") - */ - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":218 - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< - * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 218, __pyx_L1_error) - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":216 - * copy_shape = 0 - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":220 - * raise ValueError(u"ndarray is not C contiguous") - * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") - */ - __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L9_bool_binop_done; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":221 - * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< - * raise ValueError(u"ndarray is not Fortran contiguous") - * - */ - __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L9_bool_binop_done:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":220 - * raise ValueError(u"ndarray is not C contiguous") - * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") - */ - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":222 - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< - * - * info.buf = PyArray_DATA(self) - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 222, __pyx_L1_error) - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":220 - * raise ValueError(u"ndarray is not C contiguous") - * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":224 - * raise ValueError(u"ndarray is not Fortran contiguous") - * - * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< - * info.ndim = ndim - * if copy_shape: - */ - __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":225 - * - * info.buf = PyArray_DATA(self) - * info.ndim = ndim # <<<<<<<<<<<<<< - * if copy_shape: - * # Allocate new buffer for strides and shape info. - */ - __pyx_v_info->ndim = __pyx_v_ndim; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":226 - * info.buf = PyArray_DATA(self) - * info.ndim = ndim - * if copy_shape: # <<<<<<<<<<<<<< - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - */ - __pyx_t_1 = (__pyx_v_copy_shape != 0); - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":229 - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< - * info.shape = info.strides + ndim - * for i in range(ndim): - */ - __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":230 - * # This is allocated as one block, strides first. - * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) - * info.shape = info.strides + ndim # <<<<<<<<<<<<<< - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] - */ - __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":231 - * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) - * info.shape = info.strides + ndim - * for i in range(ndim): # <<<<<<<<<<<<<< - * info.strides[i] = PyArray_STRIDES(self)[i] - * info.shape[i] = PyArray_DIMS(self)[i] - */ - __pyx_t_4 = __pyx_v_ndim; - for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_i = __pyx_t_5; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":232 - * info.shape = info.strides + ndim - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< - * info.shape[i] = PyArray_DIMS(self)[i] - * else: - */ - (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":233 - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] - * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< - * else: - * info.strides = PyArray_STRIDES(self) - */ - (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":226 - * info.buf = PyArray_DATA(self) - * info.ndim = ndim - * if copy_shape: # <<<<<<<<<<<<<< - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - */ - goto __pyx_L11; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":235 - * info.shape[i] = PyArray_DIMS(self)[i] - * else: - * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL - */ - /*else*/ { - __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":236 - * else: - * info.strides = PyArray_STRIDES(self) - * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) - */ - __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); - } - __pyx_L11:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":237 - * info.strides = PyArray_STRIDES(self) - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = PyArray_ITEMSIZE(self) - * info.readonly = not PyArray_ISWRITEABLE(self) - */ - __pyx_v_info->suboffsets = NULL; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":238 - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< - * info.readonly = not PyArray_ISWRITEABLE(self) - * - */ - __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":239 - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) - * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< - * - * cdef int t - */ - __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":242 - * - * cdef int t - * cdef char* f = NULL # <<<<<<<<<<<<<< - * cdef dtype descr = self.descr - * cdef int offset - */ - __pyx_v_f = NULL; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":243 - * cdef int t - * cdef char* f = NULL - * cdef dtype descr = self.descr # <<<<<<<<<<<<<< - * cdef int offset - * - */ - __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); - __Pyx_INCREF(__pyx_t_3); - __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":246 - * cdef int offset - * - * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< - * - * if not hasfields and not copy_shape: - */ - __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":248 - * cdef bint hasfields = PyDataType_HASFIELDS(descr) - * - * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< - * # do not call releasebuffer - * info.obj = None - */ - __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L15_bool_binop_done; - } - __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L15_bool_binop_done:; - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":250 - * if not hasfields and not copy_shape: - * # do not call releasebuffer - * info.obj = None # <<<<<<<<<<<<<< - * else: - * # need to call releasebuffer - */ - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = Py_None; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":248 - * cdef bint hasfields = PyDataType_HASFIELDS(descr) - * - * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< - * # do not call releasebuffer - * info.obj = None - */ - goto __pyx_L14; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":253 - * else: - * # need to call releasebuffer - * info.obj = self # <<<<<<<<<<<<<< - * - * if not hasfields: - */ - /*else*/ { - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - } - __pyx_L14:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":255 - * info.obj = self - * - * if not hasfields: # <<<<<<<<<<<<<< - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or - */ - __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":256 - * - * if not hasfields: - * t = descr.type_num # <<<<<<<<<<<<<< - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - */ - __pyx_t_4 = __pyx_v_descr->type_num; - __pyx_v_t = __pyx_t_4; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":257 - * if not hasfields: - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); - if (!__pyx_t_2) { - goto __pyx_L20_next_or; - } else { - } - __pyx_t_2 = (__pyx_v_little_endian != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L19_bool_binop_done; - } - __pyx_L20_next_or:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258 - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" - */ - __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L19_bool_binop_done; - } - __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L19_bool_binop_done:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":257 - * if not hasfields: - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":259 - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 259, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 259, __pyx_L1_error) - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":257 - * if not hasfields: - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":260 - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" - */ - switch (__pyx_v_t) { - case NPY_BYTE: - __pyx_v_f = ((char *)"b"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":261 - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" - */ - case NPY_UBYTE: - __pyx_v_f = ((char *)"B"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":262 - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" - */ - case NPY_SHORT: - __pyx_v_f = ((char *)"h"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":263 - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" - */ - case NPY_USHORT: - __pyx_v_f = ((char *)"H"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":264 - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" - */ - case NPY_INT: - __pyx_v_f = ((char *)"i"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":265 - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" - */ - case NPY_UINT: - __pyx_v_f = ((char *)"I"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":266 - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" - */ - case NPY_LONG: - __pyx_v_f = ((char *)"l"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":267 - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" - */ - case NPY_ULONG: - __pyx_v_f = ((char *)"L"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":268 - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" - */ - case NPY_LONGLONG: - __pyx_v_f = ((char *)"q"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":269 - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" - */ - case NPY_ULONGLONG: - __pyx_v_f = ((char *)"Q"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" - */ - case NPY_FLOAT: - __pyx_v_f = ((char *)"f"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":271 - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" - */ - case NPY_DOUBLE: - __pyx_v_f = ((char *)"d"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":272 - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" - */ - case NPY_LONGDOUBLE: - __pyx_v_f = ((char *)"g"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":273 - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" - */ - case NPY_CFLOAT: - __pyx_v_f = ((char *)"Zf"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" - */ - case NPY_CDOUBLE: - __pyx_v_f = ((char *)"Zd"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":275 - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f = "O" - * else: - */ - case NPY_CLONGDOUBLE: - __pyx_v_f = ((char *)"Zg"); - break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":276 - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - */ - case NPY_OBJECT: - __pyx_v_f = ((char *)"O"); - break; - default: - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":278 - * elif t == NPY_OBJECT: f = "O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * info.format = f - * return - */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(1, 278, __pyx_L1_error) - break; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":279 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * info.format = f # <<<<<<<<<<<<<< - * return - * else: - */ - __pyx_v_info->format = __pyx_v_f; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280 - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * info.format = f - * return # <<<<<<<<<<<<<< - * else: - * info.format = stdlib.malloc(_buffer_format_string_len) - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":255 - * info.obj = self - * - * if not hasfields: # <<<<<<<<<<<<<< - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":282 - * return - * else: - * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 - */ - /*else*/ { - __pyx_v_info->format = ((char *)malloc(0xFF)); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":283 - * else: - * info.format = stdlib.malloc(_buffer_format_string_len) - * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< - * offset = 0 - * f = _util_dtypestring(descr, info.format + 1, - */ - (__pyx_v_info->format[0]) = '^'; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":284 - * info.format = stdlib.malloc(_buffer_format_string_len) - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 # <<<<<<<<<<<<<< - * f = _util_dtypestring(descr, info.format + 1, - * info.format + _buffer_format_string_len, - */ - __pyx_v_offset = 0; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":285 - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 - * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< - * info.format + _buffer_format_string_len, - * &offset) - */ - __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(1, 285, __pyx_L1_error) - __pyx_v_f = __pyx_t_7; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":288 - * info.format + _buffer_format_string_len, - * &offset) - * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< - * - * def __releasebuffer__(ndarray self, Py_buffer* info): - */ - (__pyx_v_f[0]) = '\x00'; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":197 - * # experimental exception made for __getbuffer__ and __releasebuffer__ - * # -- the details of this may change. - * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< - * # This implementation of getbuffer is geared towards Cython - * # requirements, and does not yet fullfill the PEP. - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; - } - goto __pyx_L2; - __pyx_L0:; - if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(Py_None); - __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; - } - __pyx_L2:; - __Pyx_XDECREF((PyObject *)__pyx_v_descr); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":290 - * f[0] = c'\0' # Terminate format string - * - * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< - * if PyArray_HASFIELDS(self): - * stdlib.free(info.format) - */ - -/* Python wrapper */ -static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ -static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); - __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__releasebuffer__", 0); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":291 - * - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< - * stdlib.free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - */ - __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":292 - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): - * stdlib.free(info.format) # <<<<<<<<<<<<<< - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * stdlib.free(info.strides) - */ - free(__pyx_v_info->format); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":291 - * - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< - * stdlib.free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":293 - * if PyArray_HASFIELDS(self): - * stdlib.free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * stdlib.free(info.strides) - * # info.shape was stored after info.strides in the same block - */ - __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); - if (__pyx_t_1) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":294 - * stdlib.free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * stdlib.free(info.strides) # <<<<<<<<<<<<<< - * # info.shape was stored after info.strides in the same block - * - */ - free(__pyx_v_info->strides); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":293 - * if PyArray_HASFIELDS(self): - * stdlib.free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * stdlib.free(info.strides) - * # info.shape was stored after info.strides in the same block - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":290 - * f[0] = c'\0' # Terminate format string - * - * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< - * if PyArray_HASFIELDS(self): - * stdlib.free(info.format) - */ - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":770 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":771 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":736 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< @@ -4907,13 +4096,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 771, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":770 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":735 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -4932,7 +4121,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ return __pyx_r; } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":773 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":738 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -4944,9 +4133,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":774 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":739 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< @@ -4954,13 +4146,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 774, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":773 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":738 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -4979,7 +4171,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ return __pyx_r; } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":776 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":741 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -4991,9 +4183,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":777 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":742 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< @@ -5001,13 +4196,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":776 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":741 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -5026,7 +4221,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ return __pyx_r; } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":779 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":744 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -5038,9 +4233,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":780 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":745 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< @@ -5048,13 +4246,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 780, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":779 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":744 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -5071,971 +4269,246 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; -} - -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":782 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":783 - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< - * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 783, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":782 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":785 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. - */ - -static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { - PyArray_Descr *__pyx_v_child = 0; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - PyObject *__pyx_v_fields = 0; - PyObject *__pyx_v_childname = NULL; - PyObject *__pyx_v_new_offset = NULL; - PyObject *__pyx_v_t = NULL; - char *__pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_t_7; - long __pyx_t_8; - char *__pyx_t_9; - __Pyx_RefNannySetupContext("_util_dtypestring", 0); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":790 - * - * cdef dtype child - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * cdef tuple fields - */ - __pyx_v_endian_detector = 1; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":791 - * cdef dtype child - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< - * cdef tuple fields - * - */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":794 - * cdef tuple fields - * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields - */ - if (unlikely(__pyx_v_descr->names == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 794, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 794, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 794, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); - __pyx_t_3 = 0; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":795 - * - * for childname in descr.names: - * fields = descr.fields[childname] # <<<<<<<<<<<<<< - * child, new_offset = fields - * - */ - if (unlikely(__pyx_v_descr->fields == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 795, __pyx_L1_error) - } - __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 795, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 795, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":796 - * for childname in descr.names: - * fields = descr.fields[childname] - * child, new_offset = fields # <<<<<<<<<<<<<< - * - * if (end - f) - (new_offset - offset[0]) < 15: - */ - if (likely(__pyx_v_fields != Py_None)) { - PyObject* sequence = __pyx_v_fields; - #if !CYTHON_COMPILING_IN_PYPY - Py_ssize_t size = Py_SIZE(sequence); - #else - Py_ssize_t size = PySequence_Size(sequence); - #endif - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 796, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 796, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 796, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 796, __pyx_L1_error) - } - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 796, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); - __pyx_t_3 = 0; - __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); - __pyx_t_4 = 0; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":798 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 798, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 798, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); - if (__pyx_t_6) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":799 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< - * - * if ((child.byteorder == c'>' and little_endian) or - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 799, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 799, __pyx_L1_error) - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":798 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":801 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); - if (!__pyx_t_7) { - goto __pyx_L8_next_or; - } else { - } - __pyx_t_7 = (__pyx_v_little_endian != 0); - if (!__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_L8_next_or:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":802 - * - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * # One could encode it in the format string and have Cython - */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); - if (__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_6 = __pyx_t_7; - __pyx_L7_bool_binop_done:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":801 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - if (__pyx_t_6) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":803 - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * # One could encode it in the format string and have Cython - * # complain instead, BUT: < and > in format strings also imply - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 803, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 803, __pyx_L1_error) - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":801 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":813 - * - * # Output padding bytes - * while offset[0] < new_offset: # <<<<<<<<<<<<<< - * f[0] = 120 # "x"; pad byte - * f += 1 - */ - while (1) { - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (!__pyx_t_6) break; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":814 - * # Output padding bytes - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< - * f += 1 - * offset[0] += 1 - */ - (__pyx_v_f[0]) = 0x78; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":815 - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte - * f += 1 # <<<<<<<<<<<<<< - * offset[0] += 1 - * - */ - __pyx_v_f = (__pyx_v_f + 1); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":816 - * f[0] = 120 # "x"; pad byte - * f += 1 - * offset[0] += 1 # <<<<<<<<<<<<<< - * - * offset[0] += child.itemsize - */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":818 - * offset[0] += 1 - * - * offset[0] += child.itemsize # <<<<<<<<<<<<<< - * - * if not PyDataType_HASFIELDS(child): - */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":820 - * offset[0] += child.itemsize - * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: - */ - __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); - if (__pyx_t_6) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821 - * - * if not PyDataType_HASFIELDS(child): - * t = child.type_num # <<<<<<<<<<<<<< - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") - */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 821, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); - __pyx_t_4 = 0; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":822 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") - * - */ - __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); - if (__pyx_t_6) { - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":823 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< - * - * # Until ticket #99 is fixed, use integers to avoid warnings - */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 823, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 823, __pyx_L1_error) - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":822 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") - * - */ - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":826 - * - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 826, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 826, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 826, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 98; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827 - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 827, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 827, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 827, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 66; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":828 - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 828, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 828, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 828, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x68; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":829 - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 829, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 829, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 829, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 72; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830 - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 830, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 830, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 830, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x69; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":831 - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 831, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 831, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 831, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 73; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":832 - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 832, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 832, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 832, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x6C; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833 - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 833, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 833, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 833, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 76; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":834 - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 834, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 834, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x71; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":835 - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 835, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 835, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 81; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836 - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 836, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 836, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 836, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x66; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837 - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 837, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 837, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x64; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":838 - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 838, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 838, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 838, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x67; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":839 - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 839, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 839, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 839, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x66; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":840 - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 840, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 840, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 840, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x64; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":841 - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 841, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 841, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 841, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x67; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842 - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 842, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 842, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 842, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 79; - goto __pyx_L15; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":844 - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * f += 1 - * else: - */ - /*else*/ { - __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 844, __pyx_L1_error) - } - __pyx_L15:; - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":845 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * f += 1 # <<<<<<<<<<<<<< - * else: - * # Cython ignores struct boundary information ("T{...}"), - */ - __pyx_v_f = (__pyx_v_f + 1); +} - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":820 - * offset[0] += child.itemsize +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: - */ - goto __pyx_L13; - } - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":849 - * # Cython ignores struct boundary information ("T{...}"), - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< - * return f + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ - /*else*/ { - __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(1, 849, __pyx_L1_error) - __pyx_v_f = __pyx_t_9; - } - __pyx_L13:; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":794 - * cdef tuple fields - * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields - */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":850 - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) - * return f # <<<<<<<<<<<<<< + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":748 * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * + * cdef inline tuple PyDataType_SHAPE(dtype d): */ - __pyx_r = __pyx_v_f; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":785 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_child); - __Pyx_XDECREF(__pyx_v_fields); - __Pyx_XDECREF(__pyx_v_childname); - __Pyx_XDECREF(__pyx_v_new_offset); - __Pyx_XDECREF(__pyx_v_t); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":966 - * +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * cdef PyObject* baseptr - * if base is None: + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ -static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { - PyObject *__pyx_v_baseptr; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; - __Pyx_RefNannySetupContext("set_array_base", 0); + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":968 - * cdef inline void set_array_base(ndarray arr, object base): - * cdef PyObject* baseptr - * if base is None: # <<<<<<<<<<<<<< - * baseptr = NULL - * else: + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":751 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ - __pyx_t_1 = (__pyx_v_base == Py_None); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":969 - * cdef PyObject* baseptr - * if base is None: - * baseptr = NULL # <<<<<<<<<<<<<< - * else: - * Py_INCREF(base) # important to do this before decref below! + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":752 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () */ - __pyx_v_baseptr = NULL; + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":968 - * cdef inline void set_array_base(ndarray arr, object base): - * cdef PyObject* baseptr - * if base is None: # <<<<<<<<<<<<<< - * baseptr = NULL - * else: + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":751 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ - goto __pyx_L3; } - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":971 - * baseptr = NULL - * else: - * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< - * baseptr = base - * Py_XDECREF(arr.base) + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":754 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * */ /*else*/ { - Py_INCREF(__pyx_v_base); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":972 - * else: - * Py_INCREF(base) # important to do this before decref below! - * baseptr = base # <<<<<<<<<<<<<< - * Py_XDECREF(arr.base) - * arr.base = baseptr + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ - __pyx_v_baseptr = ((PyObject *)__pyx_v_base); - } - __pyx_L3:; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":973 - * Py_INCREF(base) # important to do this before decref below! - * baseptr = base - * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< - * arr.base = baseptr + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":931 + * int _import_umath() except -1 * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ - Py_XDECREF(__pyx_v_arr->base); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":974 - * baseptr = base - * Py_XDECREF(arr.base) - * arr.base = baseptr # <<<<<<<<<<<<<< +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":932 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) * - * cdef inline object get_array_base(ndarray arr): */ - __pyx_v_arr->base = __pyx_v_baseptr; + Py_INCREF(__pyx_v_base); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":966 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":933 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":931 + * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * cdef PyObject* baseptr - * if base is None: + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":976 - * arr.base = baseptr +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":935 + * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * if arr.base is NULL: - * return None + * base = PyArray_BASE(arr) + * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":977 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":936 * * cdef inline object get_array_base(ndarray arr): - * if arr.base is NULL: # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: * return None - * else: */ - __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); - if (__pyx_t_1) { + __pyx_v_base = PyArray_BASE(__pyx_v_arr); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":978 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":937 * cdef inline object get_array_base(ndarray arr): - * if arr.base is NULL: + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":938 + * base = PyArray_BASE(arr) + * if base is NULL: * return None # <<<<<<<<<<<<<< - * else: - * return arr.base + * return base + * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(Py_None); - __pyx_r = Py_None; + __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":977 - * + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":937 * cdef inline object get_array_base(ndarray arr): - * if arr.base is NULL: # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< * return None - * else: + * return base */ } - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":980 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":939 + * if base is NULL: * return None - * else: - * return arr.base # <<<<<<<<<<<<<< - * + * return base # <<<<<<<<<<<<<< * + * # Versions of the import_* functions which are more suitable for */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); - __pyx_r = ((PyObject *)__pyx_v_arr->base); - goto __pyx_L0; - } + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":976 - * arr.base = baseptr + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":935 + * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * if arr.base is NULL: - * return None + * base = PyArray_BASE(arr) + * if base is NULL: */ /* function exit code */ @@ -6045,12 +4518,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py return __pyx_r; } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":985 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":943 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: - * _import_array() + * __pyx_import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { @@ -6064,13 +4537,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":986 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":944 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< - * _import_array() + * __pyx_import_array() * except Exception: */ { @@ -6082,20 +4558,20 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":987 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":945 * cdef inline int import_array() except -1: * try: - * _import_array() # <<<<<<<<<<<<<< + * __pyx_import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 987, __pyx_L3_error) + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 945, __pyx_L3_error) - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":986 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":944 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< - * _import_array() + * __pyx_import_array() * except Exception: */ } @@ -6104,11 +4580,10 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; - __Pyx_PyThreadState_assign - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":988 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":946 * try: - * _import_array() + * __pyx_import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * @@ -6116,35 +4591,34 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 988, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 946, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":989 - * _import_array() + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":947 + * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 989, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 947, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 989, __pyx_L5_except_error) + __PYX_ERR(1, 947, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":986 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":944 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< - * _import_array() + * __pyx_import_array() * except Exception: */ - __Pyx_PyThreadState_assign __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); @@ -6153,12 +4627,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_L8_try_end:; } - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":985 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":943 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: - * _import_array() + * __pyx_import_array() */ /* function exit code */ @@ -6176,7 +4650,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { return __pyx_r; } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":991 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":949 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -6195,9 +4669,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":992 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":950 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -6213,16 +4690,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":993 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":951 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 993, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 951, __pyx_L3_error) - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":992 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":950 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -6235,9 +4712,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; - __Pyx_PyThreadState_assign - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":994 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":952 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -6247,35 +4723,34 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 994, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 952, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":995 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":953 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 995, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 953, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 995, __pyx_L5_except_error) + __PYX_ERR(1, 953, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":992 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":950 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ - __Pyx_PyThreadState_assign __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); @@ -6284,7 +4759,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_L8_try_end:; } - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":991 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":949 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -6307,7 +4782,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { return __pyx_r; } -/* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":997 +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":955 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -6326,9 +4801,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":998 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":956 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -6344,94 +4822,269 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":999 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":957 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 999, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 957, __pyx_L3_error) + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":956 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":958 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 958, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":959 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef extern from *: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 959, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 959, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":956 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":955 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":969 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":981 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":969 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":984 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_datetime64_object", 0); + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":996 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":984 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":999 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":1006 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":999 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":1009 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":1013 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":998 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":1009 * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; - __Pyx_PyThreadState_assign - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1000 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") - */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1000, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1001 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< +/* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":1016 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1001, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1001, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":998 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":1020 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< */ - __Pyx_PyThreadState_assign - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":997 - * raise ImportError("numpy.core.umath failed to import") + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":1016 * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6440,34 +5093,52 @@ static PyMethodDef __pyx_methods[] = { }; #if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_box_overlaps(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_box_overlaps}, + {0, NULL} +}; +#endif + static struct PyModuleDef __pyx_moduledef = { - #if PY_VERSION_HEX < 0x03020000 - { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, - #else PyModuleDef_HEAD_INIT, - #endif "box_overlaps", 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else -1, /* m_size */ + #endif __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else NULL, /* m_reload */ + #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, - {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, - {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_n_s_K, __pyx_k_K, sizeof(__pyx_k_K), 0, 0, 1, 1}, {&__pyx_n_s_M, __pyx_k_M, sizeof(__pyx_k_M), 0, 0, 1, 1}, {&__pyx_n_s_N, __pyx_k_N, sizeof(__pyx_k_N), 0, 0, 1, 1}, - {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, - {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_acc_box, __pyx_k_acc_box, sizeof(__pyx_k_acc_box), 0, 0, 1, 1}, {&__pyx_n_s_acc_score, __pyx_k_acc_score, sizeof(__pyx_k_acc_score), 0, 0, 1, 1}, {&__pyx_n_s_bbox_intersections, __pyx_k_bbox_intersections, sizeof(__pyx_k_bbox_intersections), 0, 0, 1, 1}, @@ -6497,8 +5168,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_m, __pyx_k_m, sizeof(__pyx_k_m), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, - {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, - {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, @@ -6510,23 +5180,20 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_thresh, __pyx_k_thresh, sizeof(__pyx_k_thresh), 0, 0, 1, 1}, {&__pyx_n_s_ua, __pyx_k_ua, sizeof(__pyx_k_ua), 0, 0, 1, 1}, - {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, {&__pyx_n_s_utils_box_overlaps, __pyx_k_utils_box_overlaps, sizeof(__pyx_k_utils_box_overlaps), 0, 0, 1, 1}, {&__pyx_kp_s_utils_box_overlaps_pyx, __pyx_k_utils_box_overlaps_pyx, sizeof(__pyx_k_utils_box_overlaps_pyx), 0, 0, 1, 0}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; -static int __Pyx_InitCachedBuiltins(void) { +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 35, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 218, __pyx_L1_error) - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 799, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 989, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 947, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } -static int __Pyx_InitCachedConstants(void) { +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); @@ -6552,17 +5219,6 @@ static int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); - /* "utils/box_overlaps.pyx":122 - * - * for m in range(M): - * det2 = dets_all[m, :] # <<<<<<<<<<<<<< - * - * bi0 = max(det[0], det2[0]) - */ - __pyx_slice__3 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__3)) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__3); - __Pyx_GIVEREF(__pyx_slice__3); - /* "utils/box_overlaps.pyx":141 * continue * @@ -6570,117 +5226,31 @@ static int __Pyx_InitCachedConstants(void) { * acc_score += det2[4] * */ - __pyx_slice__4 = PySlice_New(__pyx_int_0, __pyx_int_4, Py_None); if (unlikely(!__pyx_slice__4)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__4); - __Pyx_GIVEREF(__pyx_slice__4); - - /* "utils/box_overlaps.pyx":144 - * acc_score += det2[4] - * - * dets_voted[i][0:4] = acc_box / acc_score # <<<<<<<<<<<<<< - * dets_voted[i][4] = det[4] # Keep the original score - * - */ - __pyx_slice__5 = PySlice_New(__pyx_int_0, __pyx_int_4, Py_None); if (unlikely(!__pyx_slice__5)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__5); - __Pyx_GIVEREF(__pyx_slice__5); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":218 - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< - * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":222 - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< - * - * info.buf = PyArray_DATA(self) - */ - __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":259 - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - */ - __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 259, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":799 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< - * - * if ((child.byteorder == c'>' and little_endian) or - */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 799, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":803 - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * # One could encode it in the format string and have Cython - * # complain instead, BUT: < and > in format strings also imply - */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 803, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":823 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< - * - * # Until ticket #99 is fixed, use integers to avoid warnings - */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 823, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_slice__3 = PySlice_New(__pyx_int_0, __pyx_int_4, Py_None); if (unlikely(!__pyx_slice__3)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__3); + __Pyx_GIVEREF(__pyx_slice__3); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":989 - * _import_array() + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":947 + * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 989, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":995 + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":953 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 995, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); - - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1001 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - */ - __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 1001, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 953, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); /* "utils/box_overlaps.pyx":17 * @@ -6689,10 +5259,10 @@ static int __Pyx_InitCachedConstants(void) { * np.ndarray[DTYPE_t, ndim=2] boxes, * np.ndarray[DTYPE_t, ndim=2] query_boxes): */ - __pyx_tuple__15 = PyTuple_Pack(11, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_overlaps, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); - __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_utils_box_overlaps_pyx, __pyx_n_s_bbox_overlaps, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 17, __pyx_L1_error) + __pyx_tuple__6 = PyTuple_Pack(11, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_overlaps, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_utils_box_overlaps_pyx, __pyx_n_s_bbox_overlaps, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 17, __pyx_L1_error) /* "utils/box_overlaps.pyx":59 * return overlaps @@ -6701,10 +5271,10 @@ static int __Pyx_InitCachedConstants(void) { * np.ndarray[DTYPE_t, ndim=2] boxes, * np.ndarray[DTYPE_t, ndim=2] query_boxes): */ - __pyx_tuple__17 = PyTuple_Pack(11, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_intersec, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); - __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_utils_box_overlaps_pyx, __pyx_n_s_bbox_intersections, 59, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 59, __pyx_L1_error) + __pyx_tuple__8 = PyTuple_Pack(11, __pyx_n_s_boxes, __pyx_n_s_query_boxes, __pyx_n_s_N, __pyx_n_s_K, __pyx_n_s_intersec, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_box_area, __pyx_n_s_ua, __pyx_n_s_k, __pyx_n_s_n); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_utils_box_overlaps_pyx, __pyx_n_s_bbox_intersections, 59, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 59, __pyx_L1_error) /* "utils/box_overlaps.pyx":99 * @@ -6713,10 +5283,10 @@ static int __Pyx_InitCachedConstants(void) { * np.ndarray[float, ndim=2] dets_NMS, * np.ndarray[float, ndim=2] dets_all): */ - __pyx_tuple__19 = PyTuple_Pack(21, __pyx_n_s_dets_NMS, __pyx_n_s_dets_all, __pyx_n_s_dets_voted, __pyx_n_s_N, __pyx_n_s_M, __pyx_n_s_det, __pyx_n_s_acc_box, __pyx_n_s_acc_score, __pyx_n_s_det2, __pyx_n_s_bi0, __pyx_n_s_bi1, __pyx_n_s_bit2, __pyx_n_s_bi3, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_ua, __pyx_n_s_thresh, __pyx_n_s_i, __pyx_n_s_m, __pyx_n_s_bi2, __pyx_n_s_ov); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); - __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(2, 0, 21, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_utils_box_overlaps_pyx, __pyx_n_s_box_vote, 99, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 99, __pyx_L1_error) + __pyx_tuple__10 = PyTuple_Pack(21, __pyx_n_s_dets_NMS, __pyx_n_s_dets_all, __pyx_n_s_dets_voted, __pyx_n_s_N, __pyx_n_s_M, __pyx_n_s_det, __pyx_n_s_acc_box, __pyx_n_s_acc_score, __pyx_n_s_det2, __pyx_n_s_bi0, __pyx_n_s_bi1, __pyx_n_s_bit2, __pyx_n_s_bi3, __pyx_n_s_iw, __pyx_n_s_ih, __pyx_n_s_ua, __pyx_n_s_thresh, __pyx_n_s_i, __pyx_n_s_m, __pyx_n_s_bi2, __pyx_n_s_ov); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 21, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_utils_box_overlaps_pyx, __pyx_n_s_box_vote, 99, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -6724,7 +5294,7 @@ static int __Pyx_InitCachedConstants(void) { return -1; } -static int __Pyx_InitGlobals(void) { +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { /* InitThreads.init */ #ifdef WITH_THREAD PyEval_InitThreads(); @@ -6741,28 +5311,245 @@ if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return -1; } +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 200, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 223, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 227, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 239, __pyx_L1_error) + __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 771, __pyx_L1_error) + __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 775, __pyx_L1_error) + __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 783, __pyx_L1_error) + __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 785, __pyx_L1_error) + __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 787, __pyx_L1_error) + __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 789, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + #if PY_MAJOR_VERSION < 3 -PyMODINIT_FUNC initbox_overlaps(void); /*proto*/ -PyMODINIT_FUNC initbox_overlaps(void) +__Pyx_PyMODINIT_FUNC initbox_overlaps(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initbox_overlaps(void) #else -PyMODINIT_FUNC PyInit_box_overlaps(void); /*proto*/ -PyMODINIT_FUNC PyInit_box_overlaps(void) +__Pyx_PyMODINIT_FUNC PyInit_box_overlaps(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_box_overlaps(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_box_overlaps(PyObject *__pyx_pyinit_module) +#endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannyDeclarations - #if CYTHON_REFNANNY - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); - if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'box_overlaps' has already been imported. Re-initialisation is not supported."); + return -1; } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif - __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_box_overlaps(void)", 0); + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_box_overlaps(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) @@ -6778,6 +5565,9 @@ PyMODINIT_FUNC PyInit_box_overlaps(void) #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif @@ -6789,19 +5579,23 @@ PyMODINIT_FUNC PyInit_box_overlaps(void) #endif #endif /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("box_overlaps", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); - #endif + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) @@ -6809,7 +5603,7 @@ PyMODINIT_FUNC PyInit_box_overlaps(void) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_utils__box_overlaps) { - if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { @@ -6818,30 +5612,19 @@ PyMODINIT_FUNC PyInit_box_overlaps(void) if (unlikely(PyDict_SetItemString(modules, "utils.box_overlaps", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global init code ---*/ - /*--- Variable export code ---*/ - /*--- Function export code ---*/ - /*--- Type init code ---*/ - /*--- Type import code ---*/ - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", - #if CYTHON_COMPILING_IN_PYPY - sizeof(PyTypeObject), - #else - sizeof(PyHeapTypeObject), - #endif - 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(2, 9, __pyx_L1_error) - __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(1, 155, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(1, 168, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(1, 172, __pyx_L1_error) - __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(1, 181, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(1, 861, __pyx_L1_error) - /*--- Variable import code ---*/ - /*--- Function import code ---*/ + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) @@ -6866,7 +5649,7 @@ PyMODINIT_FUNC PyInit_box_overlaps(void) * ctypedef float DTYPE_t * */ - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -6915,17 +5698,17 @@ PyMODINIT_FUNC PyInit_box_overlaps(void) * # Fast R-CNN * # Copyright (c) 2015 Microsoft */ - __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "../../../../../home/jeasinema/anaconda3/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":997 - * raise ImportError("numpy.core.umath failed to import") + /* "../../miniconda3/lib/python3.8/site-packages/numpy/__init__.pxd":1016 * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. */ /*--- Wrapped vars code ---*/ @@ -6936,18 +5719,20 @@ PyMODINIT_FUNC PyInit_box_overlaps(void) __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { - __Pyx_AddTraceback("init utils.box_overlaps", 0, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("init utils.box_overlaps", __pyx_clineno, __pyx_lineno, __pyx_filename); } - Py_DECREF(__pyx_m); __pyx_m = 0; + Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init utils.box_overlaps"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); - #if PY_MAJOR_VERSION < 3 - return; - #else + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 return __pyx_m; + #else + return; #endif } @@ -6957,9 +5742,9 @@ PyMODINIT_FUNC PyInit_box_overlaps(void) static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; - m = PyImport_ImportModule((char *)modname); + m = PyImport_ImportModule(modname); if (!m) goto end; - p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: @@ -6969,6 +5754,20 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #endif +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); @@ -7045,7 +5844,7 @@ static int __Pyx_ParseOptionalKeywords( } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 - if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { @@ -7072,7 +5871,7 @@ static int __Pyx_ParseOptionalKeywords( while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; @@ -7088,7 +5887,7 @@ static int __Pyx_ParseOptionalKeywords( while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; @@ -7126,29 +5925,23 @@ static int __Pyx_ParseOptionalKeywords( } /* ArgTypeTest */ -static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); -} -static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, - const char *name, int exact) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } - if (none_allowed && obj == Py_None) return 1; else if (exact) { - if (likely(Py_TYPE(obj) == type)) return 1; #if PY_MAJOR_VERSION == 2 - else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { - if (likely(PyObject_TypeCheck(obj, type))) return 1; + if (likely(__Pyx_TypeCheck(obj, type))) return 1; } - __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } @@ -7198,7 +5991,7 @@ static int __Pyx_BufFmt_ParseNumber(const char** ts) { return -1; } else { count = *t++ - '0'; - while (*t >= '0' && *t < '9') { + while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } @@ -7219,6 +6012,7 @@ static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { + case '?': return "'bool'"; case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; @@ -7261,7 +6055,7 @@ static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { - case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); @@ -7345,7 +6139,7 @@ static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; - case 'B': case 'H': case 'I': case 'L': case 'Q': + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); @@ -7485,13 +6279,11 @@ static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { ctx->is_complex = 0; return 0; } -static CYTHON_INLINE PyObject * +static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; - int i = 0, number; - int ndim = ctx->head->field->type->ndim; -; + int i = 0, number, ndim; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, @@ -7499,6 +6291,7 @@ __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; @@ -7623,18 +6416,20 @@ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const cha __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } - case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': - if (ctx->enc_type == *ts && got_Z == ctx->is_complex && - ctx->enc_packmode == ctx->new_packmode) { + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } + CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; @@ -7662,24 +6457,30 @@ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const cha } } } -static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) { + +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} +static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } -static CYTHON_INLINE int __Pyx_GetBufferAndValidate( +static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { - if (obj == Py_None || obj == NULL) { + buf->buf = NULL; + if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); - return 0; + return -1; } - buf->buf = NULL; - if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail; - if (buf->ndim != nd) { + if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); @@ -7690,7 +6491,7 @@ static CYTHON_INLINE int __Pyx_GetBufferAndValidate( __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } - if ((unsigned)buf->itemsize != dtype->size) { + if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", @@ -7700,35 +6501,73 @@ static CYTHON_INLINE int __Pyx_GetBufferAndValidate( if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; - __Pyx_ZeroBuffer(buf); + __Pyx_SafeReleaseBuffer(buf); return -1; } -static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { - if (info->buf == NULL) return; - if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; - __Pyx_ReleaseBuffer(info); + +/* PyDictVersioning */ + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); } +#endif /* GetModuleGlobalName */ - static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + #if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { - Py_INCREF(result); - } else { + return __Pyx_NewRef(result); + } +#endif #else result = PyObject_GetItem(__pyx_d, name); - if (!result) { - PyErr_Clear(); -#endif - result = __Pyx_GetBuiltinName(name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); } - return result; + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); } /* PyObjectCall */ - #if CYTHON_COMPILING_IN_CPYTHON + #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; @@ -7748,12 +6587,12 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #endif /* ExtTypeTest */ - static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } - if (likely(PyObject_TypeCheck(obj, type))) + if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); @@ -7761,13 +6600,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg } /* BufferIndexError */ - static void __Pyx_RaiseBufferIndexError(int axis) { + static void __Pyx_RaiseBufferIndexError(int axis) { PyErr_Format(PyExc_IndexError, "Out of bounds on buffer access (axis %d)", axis); } /* PyErrFetchRestore */ - #if CYTHON_FAST_THREAD_STATE + #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; @@ -7790,15 +6629,133 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject } #endif +/* GetItemInt */ + static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ObjectGetItem */ + #if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + /* BufferFallbackError */ - static void __Pyx_RaiseBufferFallbackError(void) { + static void __Pyx_RaiseBufferFallbackError(void) { PyErr_SetString(PyExc_ValueError, "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); } /* PyIntBinop */ - #if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; @@ -7835,6 +6792,7 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED goto long_long; #endif } + CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); @@ -7845,6 +6803,7 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED goto long_long; #endif } + CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); @@ -7855,152 +6814,69 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED goto long_long; #endif } + CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - case -4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - case 4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - default: return PyLong_Type.tp_as_number->nb_add(op1, op2); - } - } - x = a + b; - return PyLong_FromLong(x); -#ifdef HAVE_LONG_LONG - long_long: - llx = lla + llb; - return PyLong_FromLongLong(llx); -#endif - - - } - #endif - if (PyFloat_CheckExact(op1)) { - const long b = intval; - double a = PyFloat_AS_DOUBLE(op1); - double result; - PyFPE_START_PROTECT("add", return NULL) - result = ((double)a) + (double)b; - PyFPE_END_PROTECT(result) - return PyFloat_FromDouble(result); - } - return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); -} -#endif - -/* GetItemInt */ - static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (!j) return NULL; - r = PyObject_GetItem(o, j); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyList_GET_SIZE(o); - } - if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyList_GET_SIZE(o)))) { - PyObject *r = PyList_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyTuple_GET_SIZE(o); - } - if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; #endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); - } + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); } - return m->sq_item(o, i); } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + } -#else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } +#endif /* SliceObject */ - static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value, + static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { @@ -8098,7 +6974,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, } /* SetItemInt */ - static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { int r; if (!j) return -1; r = PyObject_SetItem(o, j, v); @@ -8110,7 +6986,7 @@ static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObje #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); - if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) { + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { PyObject* old = PyList_GET_ITEM(o, n); Py_INCREF(v); PyList_SET_ITEM(o, n, v); @@ -8135,18 +7011,174 @@ static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObje } #else #if CYTHON_COMPILING_IN_PYPY - if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) { + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) #else - if (is_list || PySequence_Check(o)) { + if (is_list || PySequence_Check(o)) #endif + { return PySequence_SetItem(o, i, v); } #endif return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); } +/* GetTopmostException */ + #if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + /* RaiseException */ - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare @@ -8261,11 +7293,7 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject "raise: exception class must be a subclass of BaseException"); goto bad; } -#if PY_VERSION_HEX >= 0x03030000 if (cause) { -#else - if (cause && cause != Py_None) { -#endif PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; @@ -8275,160 +7303,108 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; - Py_INCREF(fixed_cause); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); - } - PyErr_SetObject(type, value); - if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#else - PyThreadState *tstate = PyThreadState_GET(); - PyObject* tmp_tb = tstate->curexc_traceback; - if (tb != tmp_tb) { - Py_INCREF(tb); - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_tb); - } -#endif - } -bad: - Py_XDECREF(owned_instance); - return; -} -#endif - -/* RaiseTooManyValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); -} - -/* RaiseNeedMoreValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); -} - -/* RaiseNoneIterError */ - static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - -/* SaveResetException */ - #if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); -} -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = type; - tstate->exc_value = value; - tstate->exc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } #endif - -/* PyErrExceptionMatches */ - #if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { - PyObject *exc_type = tstate->curexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - return PyErr_GivenExceptionMatches(exc_type, err); + } +bad: + Py_XDECREF(owned_instance); + return; } #endif -/* GetException */ - #if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { -#endif - PyObject *local_type, *local_value, *local_tb; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - local_type = tstate->curexc_type; - local_value = tstate->curexc_value; - local_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#else - PyErr_Fetch(&local_type, &local_value, &local_tb); -#endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE - if (unlikely(tstate->curexc_type)) -#else - if (unlikely(PyErr_Occurred())) +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; #endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); goto bad; - #if PY_MAJOR_VERSION >= 3 - if (local_tb) { - if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) - goto bad; } - #endif - Py_XINCREF(local_tb); - Py_XINCREF(local_type); - Py_XINCREF(local_value); - *type = local_type; - *value = local_value; - *tb = local_tb; -#if CYTHON_FAST_THREAD_STATE - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = local_type; - tstate->exc_value = local_value; - tstate->exc_traceback = local_tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; #else - PyErr_SetExcInfo(local_type, local_value, local_tb); + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; #endif - return 0; + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; bad: - *type = 0; - *value = 0; - *tb = 0; - Py_XDECREF(local_type); - Py_XDECREF(local_value); - Py_XDECREF(local_tb); - return -1; + Py_XDECREF(result); + return NULL; } +#endif /* Import */ - static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; - #if PY_VERSION_HEX < 0x03030000 + #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) @@ -8451,18 +7427,9 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { #if PY_MAJOR_VERSION >= 3 if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.')) { - #if PY_VERSION_HEX < 0x03030000 - PyObject *py_level = PyInt_FromLong(1); - if (!py_level) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, NULL); - Py_DECREF(py_level); - #else + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); - #endif if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; @@ -8473,12 +7440,12 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) } #endif if (!module) { - #if PY_VERSION_HEX < 0x03030000 + #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, NULL); + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( @@ -8487,7 +7454,7 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) } } bad: - #if PY_VERSION_HEX < 0x03030000 + #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); @@ -8496,43 +7463,49 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) } /* CLineInTraceback */ - static int __Pyx_CLineForTraceback(int c_line) { -#ifdef CYTHON_CLINE_IN_TRACEBACK - return ((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0; -#else + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON - PyObject **cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { - use_cline = PyDict_GetItem(*cython_runtime_dict, __pyx_n_s_cline_in_traceback); + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { - PyObject *ptype, *pvalue, *ptraceback; - PyObject *use_cline_obj; - PyErr_Fetch(&ptype, &pvalue, &ptraceback); - use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { + PyErr_Clear(); use_cline = NULL; } - PyErr_Restore(ptype, pvalue, ptraceback); } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } - else if (PyObject_Not(use_cline) != 0) { + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; -#endif } +#endif /* CodeObjectCache */ - static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; @@ -8595,7 +7568,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } @@ -8612,7 +7585,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { } /* AddTraceback */ - #include "compile.h" + #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( @@ -8671,8 +7644,9 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { - c_line = __Pyx_CLineForTraceback(c_line); + c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { @@ -8682,10 +7656,10 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( - PyThreadState_GET(), /*PyThreadState *tstate,*/ - py_code, /*PyCodeObject *code,*/ - __pyx_d, /*PyObject *globals,*/ - 0 /*PyObject *locals*/ + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); @@ -8698,142 +7672,47 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); - if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); - PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); - return -1; -} -static void __Pyx_ReleaseBuffer(Py_buffer *view) { - PyObject *obj = view->obj; - if (!obj) return; - if (PyObject_CheckBuffer(obj)) { - PyBuffer_Release(view); - return; - } - if ((0)) {} - else if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); - view->obj = NULL; - Py_DECREF(obj); -} -#endif - - - /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { - const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(unsigned int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(unsigned int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(unsigned int), - little, !is_unsigned); - } -} - -/* CIntFromPyVerify */ - #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) -#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) -#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ - {\ - func_type value = func_value;\ - if (sizeof(target_type) < sizeof(func_type)) {\ - if (unlikely(value != (func_type) (target_type) value)) {\ - func_type zero = 0;\ - if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ - return (target_type) -1;\ - if (is_unsigned && unlikely(value < zero))\ - goto raise_neg_overflow;\ - else\ - goto raise_overflow;\ - }\ - }\ - return (target_type) value;\ - } - -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) { - const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(Py_intptr_t) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(Py_intptr_t) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t), - little, !is_unsigned); - } -} - -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) -1, const_zero = (long) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); } +#endif + + + /* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } /* Declarations */ - #if CYTHON_CCOMPLEX + #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); @@ -8853,7 +7732,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif /* Arithmetic */ - #if CYTHON_CCOMPLEX + #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); @@ -8885,13 +7764,13 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; - float s = 1.0 / (b.real + b.imag * r); + float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; - float s = 1.0 / (b.imag + b.real * r); + float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } @@ -8949,7 +7828,6 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { case 1: return a; case 2: - z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); @@ -8971,7 +7849,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { theta = 0; } else { r = -a.real; - theta = atan2f(0, -1); + theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); @@ -8988,7 +7866,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif /* Declarations */ - #if CYTHON_CCOMPLEX + #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); @@ -9008,7 +7886,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif /* Arithmetic */ - #if CYTHON_CCOMPLEX + #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); @@ -9040,13 +7918,13 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; - double s = 1.0 / (b.real + b.imag * r); + double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; - double s = 1.0 / (b.imag + b.real * r); + double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } @@ -9104,7 +7982,6 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { case 1: return a; case 2: - z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); @@ -9126,7 +8003,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { theta = 0; } else { r = -a.real; - theta = atan2(0, -1); + theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); @@ -9143,55 +8020,31 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) -1, const_zero = (int) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" #endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop #endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); - } -} - -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { - const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { - if (sizeof(enum NPY_TYPES) < sizeof(long)) { + if (sizeof(unsigned int) < sizeof(long)) { return PyInt_FromLong((long) value); - } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG - } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { - if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + if (sizeof(unsigned int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG - } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } @@ -9199,14 +8052,21 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + return _PyLong_FromByteArray(bytes, sizeof(unsigned int), little, !is_unsigned); } } /* CIntFromPy */ - static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { + static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -9393,20 +8253,103 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return (unsigned int) -1; } +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(Py_intptr_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(Py_intptr_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + /* CIntFromPy */ - static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) -1, const_zero = (int) 0; + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } - return (int) val; + return (long) val; } } else #endif @@ -9415,32 +8358,32 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; @@ -9454,86 +8397,86 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) - return (int) -1; + return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif - if (sizeof(int) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } @@ -9542,7 +8485,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else - int val; + long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { @@ -9562,40 +8505,47 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return val; } #endif - return (int) -1; + return (long) -1; } } else { - int val; + long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, - "value too large to convert to int"); - return (int) -1; + "value too large to convert to long"); + return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to int"); - return (int) -1; + "can't convert negative value to long"); + return (long) -1; } /* CIntFromPy */ - static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) -1, const_zero = (long) 0; + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } - return (long) val; + return (int) val; } } else #endif @@ -9604,32 +8554,32 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; @@ -9643,86 +8593,86 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) - return (long) -1; + return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif - if (sizeof(long) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } @@ -9731,7 +8681,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else - long val; + int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { @@ -9751,28 +8701,128 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return val; } #endif - return (long) -1; + return (int) -1; } } else { - long val; + int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, - "value too large to convert to long"); - return (long) -1; + "value too large to convert to int"); + return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to long"); - return (long) -1; + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; itp_basicsize; -#else - py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); - if (!py_basicsize) - goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; -#endif - if (!strict && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd", - module_name, class_name, basicsize, size); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; - } - else if ((size_t)basicsize != size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd", - module_name, class_name, basicsize, size); - goto bad; - } - return (PyTypeObject *)result; -bad: - Py_XDECREF(py_module); - Py_XDECREF(result); - return NULL; -} -#endif - /* InitStrings */ - static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { @@ -9897,7 +8864,7 @@ static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) - PyErr_Clear(); + return -1; ++t; } return 0; @@ -9910,46 +8877,53 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { -#if PY_VERSION_HEX < 0x03030000 - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; } } + } #endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} #else - if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - if (PyUnicode_IS_ASCII(o)) { - *length = PyUnicode_GET_LENGTH(o); - return PyUnicode_AsUTF8(o); - } else { - PyUnicode_AsASCIIString(o); - return NULL; - } + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } #else - return PyUnicode_AsUTF8AndSize(o, length); + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif #endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && #endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) @@ -9973,6 +8947,33 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; @@ -9980,9 +8981,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 - if (PyInt_Check(x) || PyLong_Check(x)) + if (likely(PyInt_Check(x) || PyLong_Check(x))) #else - if (PyLong_Check(x)) + if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS @@ -9990,32 +8991,30 @@ static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; - res = PyNumber_Int(x); + res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; - res = PyNumber_Long(x); + res = m->nb_long(x); } #else - if (m && m->nb_int) { + if (likely(m && m->nb_int)) { name = "int"; - res = PyNumber_Long(x); + res = m->nb_int(x); } #endif #else - res = PyNumber_Int(x); + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } #endif - if (res) { + if (likely(res)) { #if PY_MAJOR_VERSION < 3 - if (!PyInt_Check(res) && !PyLong_Check(res)) { + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else - if (!PyLong_Check(res)) { + if (unlikely(!PyLong_CheckExact(res))) { #endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - name, name, Py_TYPE(res)->tp_name); - Py_DECREF(res); - return NULL; + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { @@ -10032,7 +9031,7 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else - return PyInt_AsSsize_t(x); + return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { @@ -10086,6 +9085,9 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_DECREF(x); return ival; } +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } diff --git a/utils/utils.py b/utils/utils.py index 462f6dced..e31e58be9 100644 --- a/utils/utils.py +++ b/utils/utils.py @@ -484,7 +484,7 @@ def label_to_gt_box3d(labels, cls='Car', coordinate='camera', T_VELO_2_CAM=None, for line in label: ret = line.split() if ret[0] in acc_cls or acc_cls == []: - h, w, l, x, y, z, r = [float(i) for i in ret[-7:]] + h, w, l, x, y, z, r = [float(i) for i in ret[8:15]] box3d = np.array([x, y, z, h, w, l, r]) boxes3d_a_label.append(box3d) if coordinate == 'lidar':