[ { "path": "LICENSE", "content": "The MIT License (MIT)\n\nCopyright (c) 2016 MrGF\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n" }, { "path": "README.md", "content": "# py-faster-rcnn-windows\npy-faster-rcnn that can compile on windows directly\n\nUsage:\n\n1. Download py-faster-rcnn from this url:\nhttps://github.com/rbgirshick/py-faster-rcnn\n\nThis version of faster-rcnn can be compiled on linux directly.\n\n2. For windows user, download the lib from this url:\nhttps://github.com/MrGF/py-faster-rcnn-windows\n\nand replace it with the original lib provided by rbgirshick.\n\nThen you can run :\n\tpython setup.py\n\tpython setup_cuda.py \nto compile the lib on windows directly. Enjoy!\n\n\nNote:\nPlease see the LICENSE on https://github.com/rbgirshick/py-faster-rcnn for details.\n" }, { "path": "lib/Makefile", "content": "all:\n\tpython setup.py build_ext --inplace\n\trm -rf build\n" }, { "path": "lib/datasets/VOCdevkit-matlab-wrapper/get_voc_opts.m", "content": "function VOCopts = get_voc_opts(path)\n\ntmp = pwd;\ncd(path);\ntry\n addpath('VOCcode');\n VOCinit;\ncatch\n rmpath('VOCcode');\n cd(tmp);\n error(sprintf('VOCcode directory not found under %s', path));\nend\nrmpath('VOCcode');\ncd(tmp);\n" }, { "path": "lib/datasets/VOCdevkit-matlab-wrapper/voc_eval.m", "content": "function res = voc_eval(path, comp_id, test_set, output_dir)\n\nVOCopts = get_voc_opts(path);\nVOCopts.testset = test_set;\n\nfor i = 1:length(VOCopts.classes)\n cls = VOCopts.classes{i};\n res(i) = voc_eval_cls(cls, VOCopts, comp_id, output_dir);\nend\n\nfprintf('\\n~~~~~~~~~~~~~~~~~~~~\\n');\nfprintf('Results:\\n');\naps = [res(:).ap]';\nfprintf('%.1f\\n', aps * 100);\nfprintf('%.1f\\n', mean(aps) * 100);\nfprintf('~~~~~~~~~~~~~~~~~~~~\\n');\n\nfunction res = voc_eval_cls(cls, VOCopts, comp_id, output_dir)\n\ntest_set = VOCopts.testset;\nyear = VOCopts.dataset(4:end);\n\naddpath(fullfile(VOCopts.datadir, 'VOCcode'));\n\nres_fn = sprintf(VOCopts.detrespath, comp_id, cls);\n\nrecall = [];\nprec = [];\nap = 0;\nap_auc = 0;\n\ndo_eval = (str2num(year) <= 2007) | ~strcmp(test_set, 'test');\nif do_eval\n % Bug in VOCevaldet requires that tic has been called first\n tic;\n [recall, prec, ap] = VOCevaldet(VOCopts, comp_id, cls, true);\n ap_auc = xVOCap(recall, prec);\n\n % force plot limits\n ylim([0 1]);\n xlim([0 1]);\n\n print(gcf, '-djpeg', '-r0', ...\n [output_dir '/' cls '_pr.jpg']);\nend\nfprintf('!!! %s : %.4f %.4f\\n', cls, ap, ap_auc);\n\nres.recall = recall;\nres.prec = prec;\nres.ap = ap;\nres.ap_auc = ap_auc;\n\nsave([output_dir '/' cls '_pr.mat'], ...\n 'res', 'recall', 'prec', 'ap', 'ap_auc');\n\nrmpath(fullfile(VOCopts.datadir, 'VOCcode'));\n" }, { "path": "lib/datasets/VOCdevkit-matlab-wrapper/xVOCap.m", "content": "function ap = xVOCap(rec,prec)\r\n% From the PASCAL VOC 2011 devkit\r\n\r\nmrec=[0 ; rec ; 1];\r\nmpre=[0 ; prec ; 0];\r\nfor i=numel(mpre)-1:-1:1\r\n mpre(i)=max(mpre(i),mpre(i+1));\r\nend\r\ni=find(mrec(2:end)~=mrec(1:end-1))+1;\r\nap=sum((mrec(i)-mrec(i-1)).*mpre(i));\r\n" }, { "path": "lib/datasets/__init__.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n" }, { "path": "lib/datasets/coco.py", "content": "# --------------------------------------------------------\n# Fast/er R-CNN\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nfrom datasets.imdb import imdb\nimport datasets.ds_utils as ds_utils\nfrom fast_rcnn.config import cfg\nimport os.path as osp\nimport sys\nimport os\nimport numpy as np\nimport scipy.sparse\nimport scipy.io as sio\nimport cPickle\nimport json\nimport uuid\n# COCO API\nfrom pycocotools.coco import COCO\nfrom pycocotools.cocoeval import COCOeval\nfrom pycocotools import mask as COCOmask\n\ndef _filter_crowd_proposals(roidb, crowd_thresh):\n \"\"\"\n Finds proposals that are inside crowd regions and marks them with\n overlap = -1 (for all gt rois), which means they will be excluded from\n training.\n \"\"\"\n for ix, entry in enumerate(roidb):\n overlaps = entry['gt_overlaps'].toarray()\n crowd_inds = np.where(overlaps.max(axis=1) == -1)[0]\n non_gt_inds = np.where(entry['gt_classes'] == 0)[0]\n if len(crowd_inds) == 0 or len(non_gt_inds) == 0:\n continue\n iscrowd = [int(True) for _ in xrange(len(crowd_inds))]\n crowd_boxes = ds_utils.xyxy_to_xywh(entry['boxes'][crowd_inds, :])\n non_gt_boxes = ds_utils.xyxy_to_xywh(entry['boxes'][non_gt_inds, :])\n ious = COCOmask.iou(non_gt_boxes, crowd_boxes, iscrowd)\n bad_inds = np.where(ious.max(axis=1) > crowd_thresh)[0]\n overlaps[non_gt_inds[bad_inds], :] = -1\n roidb[ix]['gt_overlaps'] = scipy.sparse.csr_matrix(overlaps)\n return roidb\n\nclass coco(imdb):\n def __init__(self, image_set, year):\n imdb.__init__(self, 'coco_' + year + '_' + image_set)\n # COCO specific config options\n self.config = {'top_k' : 2000,\n 'use_salt' : True,\n 'cleanup' : True,\n 'crowd_thresh' : 0.7,\n 'min_size' : 2}\n # name, paths\n self._year = year\n self._image_set = image_set\n self._data_path = osp.join(cfg.DATA_DIR, 'coco')\n # load COCO API, classes, class <-> id mappings\n self._COCO = COCO(self._get_ann_file())\n cats = self._COCO.loadCats(self._COCO.getCatIds())\n self._classes = tuple(['__background__'] + [c['name'] for c in cats])\n self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))\n self._class_to_coco_cat_id = dict(zip([c['name'] for c in cats],\n self._COCO.getCatIds()))\n self._image_index = self._load_image_set_index()\n # Default to roidb handler\n self.set_proposal_method('selective_search')\n self.competition_mode(False)\n\n # Some image sets are \"views\" (i.e. subsets) into others.\n # For example, minival2014 is a random 5000 image subset of val2014.\n # This mapping tells us where the view's images and proposals come from.\n self._view_map = {\n 'minival2014' : 'val2014', # 5k val2014 subset\n 'valminusminival2014' : 'val2014', # val2014 \\setminus minival2014\n }\n coco_name = image_set + year # e.g., \"val2014\"\n self._data_name = (self._view_map[coco_name]\n if self._view_map.has_key(coco_name)\n else coco_name)\n # Dataset splits that have ground-truth annotations (test splits\n # do not have gt annotations)\n self._gt_splits = ('train', 'val', 'minival')\n\n def _get_ann_file(self):\n prefix = 'instances' if self._image_set.find('test') == -1 \\\n else 'image_info'\n return osp.join(self._data_path, 'annotations',\n prefix + '_' + self._image_set + self._year + '.json')\n\n def _load_image_set_index(self):\n \"\"\"\n Load image ids.\n \"\"\"\n image_ids = self._COCO.getImgIds()\n return image_ids\n\n def _get_widths(self):\n anns = self._COCO.loadImgs(self._image_index)\n widths = [ann['width'] for ann in anns]\n return widths\n\n def image_path_at(self, i):\n \"\"\"\n Return the absolute path to image i in the image sequence.\n \"\"\"\n return self.image_path_from_index(self._image_index[i])\n\n def image_path_from_index(self, index):\n \"\"\"\n Construct an image path from the image's \"index\" identifier.\n \"\"\"\n # Example image path for index=119993:\n # images/train2014/COCO_train2014_000000119993.jpg\n file_name = ('COCO_' + self._data_name + '_' +\n str(index).zfill(12) + '.jpg')\n image_path = osp.join(self._data_path, 'images',\n self._data_name, file_name)\n assert osp.exists(image_path), \\\n 'Path does not exist: {}'.format(image_path)\n return image_path\n\n def selective_search_roidb(self):\n return self._roidb_from_proposals('selective_search')\n\n def edge_boxes_roidb(self):\n return self._roidb_from_proposals('edge_boxes_AR')\n\n def mcg_roidb(self):\n return self._roidb_from_proposals('MCG')\n\n def _roidb_from_proposals(self, method):\n \"\"\"\n Creates a roidb from pre-computed proposals of a particular methods.\n \"\"\"\n top_k = self.config['top_k']\n cache_file = osp.join(self.cache_path, self.name +\n '_{:s}_top{:d}'.format(method, top_k) +\n '_roidb.pkl')\n\n if osp.exists(cache_file):\n with open(cache_file, 'rb') as fid:\n roidb = cPickle.load(fid)\n print '{:s} {:s} roidb loaded from {:s}'.format(self.name, method,\n cache_file)\n return roidb\n\n if self._image_set in self._gt_splits:\n gt_roidb = self.gt_roidb()\n method_roidb = self._load_proposals(method, gt_roidb)\n roidb = imdb.merge_roidbs(gt_roidb, method_roidb)\n # Make sure we don't use proposals that are contained in crowds\n roidb = _filter_crowd_proposals(roidb, self.config['crowd_thresh'])\n else:\n roidb = self._load_proposals(method, None)\n with open(cache_file, 'wb') as fid:\n cPickle.dump(roidb, fid, cPickle.HIGHEST_PROTOCOL)\n print 'wrote {:s} roidb to {:s}'.format(method, cache_file)\n return roidb\n\n def _load_proposals(self, method, gt_roidb):\n \"\"\"\n Load pre-computed proposals in the format provided by Jan Hosang:\n http://www.mpi-inf.mpg.de/departments/computer-vision-and-multimodal-\n computing/research/object-recognition-and-scene-understanding/how-\n good-are-detection-proposals-really/\n For MCG, use boxes from http://www.eecs.berkeley.edu/Research/Projects/\n CS/vision/grouping/mcg/ and convert the file layout using\n lib/datasets/tools/mcg_munge.py.\n \"\"\"\n box_list = []\n top_k = self.config['top_k']\n valid_methods = [\n 'MCG',\n 'selective_search',\n 'edge_boxes_AR',\n 'edge_boxes_70']\n assert method in valid_methods\n\n print 'Loading {} boxes'.format(method)\n for i, index in enumerate(self._image_index):\n if i % 1000 == 0:\n print '{:d} / {:d}'.format(i + 1, len(self._image_index))\n\n box_file = osp.join(\n cfg.DATA_DIR, 'coco_proposals', method, 'mat',\n self._get_box_file(index))\n\n raw_data = sio.loadmat(box_file)['boxes']\n boxes = np.maximum(raw_data - 1, 0).astype(np.uint16)\n if method == 'MCG':\n # Boxes from the MCG website are in (y1, x1, y2, x2) order\n boxes = boxes[:, (1, 0, 3, 2)]\n # Remove duplicate boxes and very small boxes and then take top k\n keep = ds_utils.unique_boxes(boxes)\n boxes = boxes[keep, :]\n keep = ds_utils.filter_small_boxes(boxes, self.config['min_size'])\n boxes = boxes[keep, :]\n boxes = boxes[:top_k, :]\n box_list.append(boxes)\n # Sanity check\n im_ann = self._COCO.loadImgs(index)[0]\n width = im_ann['width']\n height = im_ann['height']\n ds_utils.validate_boxes(boxes, width=width, height=height)\n return self.create_roidb_from_box_list(box_list, gt_roidb)\n\n def gt_roidb(self):\n \"\"\"\n Return the database of ground-truth regions of interest.\n This function loads/saves from/to a cache file to speed up future calls.\n \"\"\"\n cache_file = osp.join(self.cache_path, self.name + '_gt_roidb.pkl')\n if osp.exists(cache_file):\n with open(cache_file, 'rb') as fid:\n roidb = cPickle.load(fid)\n print '{} gt roidb loaded from {}'.format(self.name, cache_file)\n return roidb\n\n gt_roidb = [self._load_coco_annotation(index)\n for index in self._image_index]\n\n with open(cache_file, 'wb') as fid:\n cPickle.dump(gt_roidb, fid, cPickle.HIGHEST_PROTOCOL)\n print 'wrote gt roidb to {}'.format(cache_file)\n return gt_roidb\n\n def _load_coco_annotation(self, index):\n \"\"\"\n Loads COCO bounding-box instance annotations. Crowd instances are\n handled by marking their overlaps (with all categories) to -1. This\n overlap value means that crowd \"instances\" are excluded from training.\n \"\"\"\n im_ann = self._COCO.loadImgs(index)[0]\n width = im_ann['width']\n height = im_ann['height']\n\n annIds = self._COCO.getAnnIds(imgIds=index, iscrowd=None)\n objs = self._COCO.loadAnns(annIds)\n # Sanitize bboxes -- some are invalid\n valid_objs = []\n for obj in objs:\n x1 = np.max((0, obj['bbox'][0]))\n y1 = np.max((0, obj['bbox'][1]))\n x2 = np.min((width - 1, x1 + np.max((0, obj['bbox'][2] - 1))))\n y2 = np.min((height - 1, y1 + np.max((0, obj['bbox'][3] - 1))))\n if obj['area'] > 0 and x2 >= x1 and y2 >= y1:\n obj['clean_bbox'] = [x1, y1, x2, y2]\n valid_objs.append(obj)\n objs = valid_objs\n num_objs = len(objs)\n\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\n gt_classes = np.zeros((num_objs), dtype=np.int32)\n overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\n seg_areas = np.zeros((num_objs), dtype=np.float32)\n\n # Lookup table to map from COCO category ids to our internal class\n # indices\n coco_cat_id_to_class_ind = dict([(self._class_to_coco_cat_id[cls],\n self._class_to_ind[cls])\n for cls in self._classes[1:]])\n\n for ix, obj in enumerate(objs):\n cls = coco_cat_id_to_class_ind[obj['category_id']]\n boxes[ix, :] = obj['clean_bbox']\n gt_classes[ix] = cls\n seg_areas[ix] = obj['area']\n if obj['iscrowd']:\n # Set overlap to -1 for all classes for crowd objects\n # so they will be excluded during training\n overlaps[ix, :] = -1.0\n else:\n overlaps[ix, cls] = 1.0\n\n ds_utils.validate_boxes(boxes, width=width, height=height)\n overlaps = scipy.sparse.csr_matrix(overlaps)\n return {'boxes' : boxes,\n 'gt_classes': gt_classes,\n 'gt_overlaps' : overlaps,\n 'flipped' : False,\n 'seg_areas' : seg_areas}\n\n def _get_box_file(self, index):\n # first 14 chars / first 22 chars / all chars + .mat\n # COCO_val2014_0/COCO_val2014_000000447/COCO_val2014_000000447991.mat\n file_name = ('COCO_' + self._data_name +\n '_' + str(index).zfill(12) + '.mat')\n return osp.join(file_name[:14], file_name[:22], file_name)\n\n def _print_detection_eval_metrics(self, coco_eval):\n IoU_lo_thresh = 0.5\n IoU_hi_thresh = 0.95\n def _get_thr_ind(coco_eval, thr):\n ind = np.where((coco_eval.params.iouThrs > thr - 1e-5) &\n (coco_eval.params.iouThrs < thr + 1e-5))[0][0]\n iou_thr = coco_eval.params.iouThrs[ind]\n assert np.isclose(iou_thr, thr)\n return ind\n\n ind_lo = _get_thr_ind(coco_eval, IoU_lo_thresh)\n ind_hi = _get_thr_ind(coco_eval, IoU_hi_thresh)\n # precision has dims (iou, recall, cls, area range, max dets)\n # area range index 0: all area ranges\n # max dets index 2: 100 per image\n precision = \\\n coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, :, 0, 2]\n ap_default = np.mean(precision[precision > -1])\n print ('~~~~ Mean and per-category AP @ IoU=[{:.2f},{:.2f}] '\n '~~~~').format(IoU_lo_thresh, IoU_hi_thresh)\n print '{:.1f}'.format(100 * ap_default)\n for cls_ind, cls in enumerate(self.classes):\n if cls == '__background__':\n continue\n # minus 1 because of __background__\n precision = coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, cls_ind - 1, 0, 2]\n ap = np.mean(precision[precision > -1])\n print '{:.1f}'.format(100 * ap)\n\n print '~~~~ Summary metrics ~~~~'\n coco_eval.summarize()\n\n def _do_detection_eval(self, res_file, output_dir):\n ann_type = 'bbox'\n coco_dt = self._COCO.loadRes(res_file)\n coco_eval = COCOeval(self._COCO, coco_dt)\n coco_eval.params.useSegm = (ann_type == 'segm')\n coco_eval.evaluate()\n coco_eval.accumulate()\n self._print_detection_eval_metrics(coco_eval)\n eval_file = osp.join(output_dir, 'detection_results.pkl')\n with open(eval_file, 'wb') as fid:\n cPickle.dump(coco_eval, fid, cPickle.HIGHEST_PROTOCOL)\n print 'Wrote COCO eval results to: {}'.format(eval_file)\n\n def _coco_results_one_category(self, boxes, cat_id):\n results = []\n for im_ind, index in enumerate(self.image_index):\n dets = boxes[im_ind].astype(np.float)\n if dets == []:\n continue\n scores = dets[:, -1]\n xs = dets[:, 0]\n ys = dets[:, 1]\n ws = dets[:, 2] - xs + 1\n hs = dets[:, 3] - ys + 1\n results.extend(\n [{'image_id' : index,\n 'category_id' : cat_id,\n 'bbox' : [xs[k], ys[k], ws[k], hs[k]],\n 'score' : scores[k]} for k in xrange(dets.shape[0])])\n return results\n\n def _write_coco_results_file(self, all_boxes, res_file):\n # [{\"image_id\": 42,\n # \"category_id\": 18,\n # \"bbox\": [258.15,41.29,348.26,243.78],\n # \"score\": 0.236}, ...]\n results = []\n for cls_ind, cls in enumerate(self.classes):\n if cls == '__background__':\n continue\n print 'Collecting {} results ({:d}/{:d})'.format(cls, cls_ind,\n self.num_classes - 1)\n coco_cat_id = self._class_to_coco_cat_id[cls]\n results.extend(self._coco_results_one_category(all_boxes[cls_ind],\n coco_cat_id))\n print 'Writing results json to {}'.format(res_file)\n with open(res_file, 'w') as fid:\n json.dump(results, fid)\n\n def evaluate_detections(self, all_boxes, output_dir):\n res_file = osp.join(output_dir, ('detections_' +\n self._image_set +\n self._year +\n '_results'))\n if self.config['use_salt']:\n res_file += '_{}'.format(str(uuid.uuid4()))\n res_file += '.json'\n self._write_coco_results_file(all_boxes, res_file)\n # Only do evaluation on non-test sets\n if self._image_set.find('test') == -1:\n self._do_detection_eval(res_file, output_dir)\n # Optionally cleanup results json file\n if self.config['cleanup']:\n os.remove(res_file)\n\n def competition_mode(self, on):\n if on:\n self.config['use_salt'] = False\n self.config['cleanup'] = False\n else:\n self.config['use_salt'] = True\n self.config['cleanup'] = True\n" }, { "path": "lib/datasets/ds_utils.py", "content": "# --------------------------------------------------------\n# Fast/er R-CNN\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport numpy as np\n\ndef unique_boxes(boxes, scale=1.0):\n \"\"\"Return indices of unique boxes.\"\"\"\n v = np.array([1, 1e3, 1e6, 1e9])\n hashes = np.round(boxes * scale).dot(v)\n _, index = np.unique(hashes, return_index=True)\n return np.sort(index)\n\ndef xywh_to_xyxy(boxes):\n \"\"\"Convert [x y w h] box format to [x1 y1 x2 y2] format.\"\"\"\n return np.hstack((boxes[:, 0:2], boxes[:, 0:2] + boxes[:, 2:4] - 1))\n\ndef xyxy_to_xywh(boxes):\n \"\"\"Convert [x1 y1 x2 y2] box format to [x y w h] format.\"\"\"\n return np.hstack((boxes[:, 0:2], boxes[:, 2:4] - boxes[:, 0:2] + 1))\n\ndef validate_boxes(boxes, width=0, height=0):\n \"\"\"Check that a set of boxes are valid.\"\"\"\n x1 = boxes[:, 0]\n y1 = boxes[:, 1]\n x2 = boxes[:, 2]\n y2 = boxes[:, 3]\n assert (x1 >= 0).all()\n assert (y1 >= 0).all()\n assert (x2 >= x1).all()\n assert (y2 >= y1).all()\n assert (x2 < width).all()\n assert (y2 < height).all()\n\ndef filter_small_boxes(boxes, min_size):\n w = boxes[:, 2] - boxes[:, 0]\n h = boxes[:, 3] - boxes[:, 1]\n keep = np.where((w >= min_size) & (h > min_size))[0]\n return keep\n" }, { "path": "lib/datasets/factory.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Factory method for easily getting imdbs by name.\"\"\"\n\n__sets = {}\n\nfrom datasets.pascal_voc import pascal_voc\nfrom datasets.coco import coco\nimport numpy as np\n\n# Set up voc__ using selective search \"fast\" mode\nfor year in ['2007', '2012']:\n for split in ['train', 'val', 'trainval', 'test']:\n name = 'voc_{}_{}'.format(year, split)\n __sets[name] = (lambda split=split, year=year: pascal_voc(split, year))\n\n# Set up coco_2014_\nfor year in ['2014']:\n for split in ['train', 'val', 'minival', 'valminusminival']:\n name = 'coco_{}_{}'.format(year, split)\n __sets[name] = (lambda split=split, year=year: coco(split, year))\n\n# Set up coco_2015_\nfor year in ['2015']:\n for split in ['test', 'test-dev']:\n name = 'coco_{}_{}'.format(year, split)\n __sets[name] = (lambda split=split, year=year: coco(split, year))\n\ndef get_imdb(name):\n \"\"\"Get an imdb (image database) by name.\"\"\"\n if not __sets.has_key(name):\n raise KeyError('Unknown dataset: {}'.format(name))\n return __sets[name]()\n\ndef list_imdbs():\n \"\"\"List all registered imdbs.\"\"\"\n return __sets.keys()\n" }, { "path": "lib/datasets/imdb.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport os\nimport os.path as osp\nimport PIL\nfrom utils.cython_bbox import bbox_overlaps\nimport numpy as np\nimport scipy.sparse\nfrom fast_rcnn.config import cfg\n\nclass imdb(object):\n \"\"\"Image database.\"\"\"\n\n def __init__(self, name):\n self._name = name\n self._num_classes = 0\n self._classes = []\n self._image_index = []\n self._obj_proposer = 'selective_search'\n self._roidb = None\n self._roidb_handler = self.default_roidb\n # Use this dict for storing dataset specific config options\n self.config = {}\n\n @property\n def name(self):\n return self._name\n\n @property\n def num_classes(self):\n return len(self._classes)\n\n @property\n def classes(self):\n return self._classes\n\n @property\n def image_index(self):\n return self._image_index\n\n @property\n def roidb_handler(self):\n return self._roidb_handler\n\n @roidb_handler.setter\n def roidb_handler(self, val):\n self._roidb_handler = val\n\n def set_proposal_method(self, method):\n method = eval('self.' + method + '_roidb')\n self.roidb_handler = method\n\n @property\n def roidb(self):\n # A roidb is a list of dictionaries, each with the following keys:\n # boxes\n # gt_overlaps\n # gt_classes\n # flipped\n if self._roidb is not None:\n return self._roidb\n self._roidb = self.roidb_handler()\n return self._roidb\n\n @property\n def cache_path(self):\n cache_path = osp.abspath(osp.join(cfg.DATA_DIR, 'cache'))\n if not os.path.exists(cache_path):\n os.makedirs(cache_path)\n return cache_path\n\n @property\n def num_images(self):\n return len(self.image_index)\n\n def image_path_at(self, i):\n raise NotImplementedError\n\n def default_roidb(self):\n raise NotImplementedError\n\n def evaluate_detections(self, all_boxes, output_dir=None):\n \"\"\"\n all_boxes is a list of length number-of-classes.\n Each list element is a list of length number-of-images.\n Each of those list elements is either an empty list []\n or a numpy array of detection.\n\n all_boxes[class][image] = [] or np.array of shape #dets x 5\n \"\"\"\n raise NotImplementedError\n\n def _get_widths(self):\n return [PIL.Image.open(self.image_path_at(i)).size[0]\n for i in xrange(self.num_images)]\n\n def append_flipped_images(self):\n num_images = self.num_images\n widths = self._get_widths()\n for i in xrange(num_images):\n boxes = self.roidb[i]['boxes'].copy()\n oldx1 = boxes[:, 0].copy()\n oldx2 = boxes[:, 2].copy()\n boxes[:, 0] = widths[i] - oldx2 - 1\n boxes[:, 2] = widths[i] - oldx1 - 1\n assert (boxes[:, 2] >= boxes[:, 0]).all()\n entry = {'boxes' : boxes,\n 'gt_overlaps' : self.roidb[i]['gt_overlaps'],\n 'gt_classes' : self.roidb[i]['gt_classes'],\n 'flipped' : True}\n self.roidb.append(entry)\n self._image_index = self._image_index * 2\n\n def evaluate_recall(self, candidate_boxes=None, thresholds=None,\n area='all', limit=None):\n \"\"\"Evaluate detection proposal recall metrics.\n\n Returns:\n results: dictionary of results with keys\n 'ar': average recall\n 'recalls': vector recalls at each IoU overlap threshold\n 'thresholds': vector of IoU overlap thresholds\n 'gt_overlaps': vector of all ground-truth overlaps\n \"\"\"\n # Record max overlap value for each gt box\n # Return vector of overlap values\n areas = { 'all': 0, 'small': 1, 'medium': 2, 'large': 3,\n '96-128': 4, '128-256': 5, '256-512': 6, '512-inf': 7}\n area_ranges = [ [0**2, 1e5**2], # all\n [0**2, 32**2], # small\n [32**2, 96**2], # medium\n [96**2, 1e5**2], # large\n [96**2, 128**2], # 96-128\n [128**2, 256**2], # 128-256\n [256**2, 512**2], # 256-512\n [512**2, 1e5**2], # 512-inf\n ]\n assert areas.has_key(area), 'unknown area range: {}'.format(area)\n area_range = area_ranges[areas[area]]\n gt_overlaps = np.zeros(0)\n num_pos = 0\n for i in xrange(self.num_images):\n # Checking for max_overlaps == 1 avoids including crowd annotations\n # (...pretty hacking :/)\n max_gt_overlaps = self.roidb[i]['gt_overlaps'].toarray().max(axis=1)\n gt_inds = np.where((self.roidb[i]['gt_classes'] > 0) &\n (max_gt_overlaps == 1))[0]\n gt_boxes = self.roidb[i]['boxes'][gt_inds, :]\n gt_areas = self.roidb[i]['seg_areas'][gt_inds]\n valid_gt_inds = np.where((gt_areas >= area_range[0]) &\n (gt_areas <= area_range[1]))[0]\n gt_boxes = gt_boxes[valid_gt_inds, :]\n num_pos += len(valid_gt_inds)\n\n if candidate_boxes is None:\n # If candidate_boxes is not supplied, the default is to use the\n # non-ground-truth boxes from this roidb\n non_gt_inds = np.where(self.roidb[i]['gt_classes'] == 0)[0]\n boxes = self.roidb[i]['boxes'][non_gt_inds, :]\n else:\n boxes = candidate_boxes[i]\n if boxes.shape[0] == 0:\n continue\n if limit is not None and boxes.shape[0] > limit:\n boxes = boxes[:limit, :]\n\n overlaps = bbox_overlaps(boxes.astype(np.float),\n gt_boxes.astype(np.float))\n\n _gt_overlaps = np.zeros((gt_boxes.shape[0]))\n for j in xrange(gt_boxes.shape[0]):\n # find which proposal box maximally covers each gt box\n argmax_overlaps = overlaps.argmax(axis=0)\n # and get the iou amount of coverage for each gt box\n max_overlaps = overlaps.max(axis=0)\n # find which gt box is 'best' covered (i.e. 'best' = most iou)\n gt_ind = max_overlaps.argmax()\n gt_ovr = max_overlaps.max()\n assert(gt_ovr >= 0)\n # find the proposal box that covers the best covered gt box\n box_ind = argmax_overlaps[gt_ind]\n # record the iou coverage of this gt box\n _gt_overlaps[j] = overlaps[box_ind, gt_ind]\n assert(_gt_overlaps[j] == gt_ovr)\n # mark the proposal box and the gt box as used\n overlaps[box_ind, :] = -1\n overlaps[:, gt_ind] = -1\n # append recorded iou coverage level\n gt_overlaps = np.hstack((gt_overlaps, _gt_overlaps))\n\n gt_overlaps = np.sort(gt_overlaps)\n if thresholds is None:\n step = 0.05\n thresholds = np.arange(0.5, 0.95 + 1e-5, step)\n recalls = np.zeros_like(thresholds)\n # compute recall for each iou threshold\n for i, t in enumerate(thresholds):\n recalls[i] = (gt_overlaps >= t).sum() / float(num_pos)\n # ar = 2 * np.trapz(recalls, thresholds)\n ar = recalls.mean()\n return {'ar': ar, 'recalls': recalls, 'thresholds': thresholds,\n 'gt_overlaps': gt_overlaps}\n\n def create_roidb_from_box_list(self, box_list, gt_roidb):\n assert len(box_list) == self.num_images, \\\n 'Number of boxes must match number of ground-truth images'\n roidb = []\n for i in xrange(self.num_images):\n boxes = box_list[i]\n num_boxes = boxes.shape[0]\n overlaps = np.zeros((num_boxes, self.num_classes), dtype=np.float32)\n\n if gt_roidb is not None and gt_roidb[i]['boxes'].size > 0:\n gt_boxes = gt_roidb[i]['boxes']\n gt_classes = gt_roidb[i]['gt_classes']\n gt_overlaps = bbox_overlaps(boxes.astype(np.float),\n gt_boxes.astype(np.float))\n argmaxes = gt_overlaps.argmax(axis=1)\n maxes = gt_overlaps.max(axis=1)\n I = np.where(maxes > 0)[0]\n overlaps[I, gt_classes[argmaxes[I]]] = maxes[I]\n\n overlaps = scipy.sparse.csr_matrix(overlaps)\n roidb.append({\n 'boxes' : boxes,\n 'gt_classes' : np.zeros((num_boxes,), dtype=np.int32),\n 'gt_overlaps' : overlaps,\n 'flipped' : False,\n 'seg_areas' : np.zeros((num_boxes,), dtype=np.float32),\n })\n return roidb\n\n @staticmethod\n def merge_roidbs(a, b):\n assert len(a) == len(b)\n for i in xrange(len(a)):\n a[i]['boxes'] = np.vstack((a[i]['boxes'], b[i]['boxes']))\n a[i]['gt_classes'] = np.hstack((a[i]['gt_classes'],\n b[i]['gt_classes']))\n a[i]['gt_overlaps'] = scipy.sparse.vstack([a[i]['gt_overlaps'],\n b[i]['gt_overlaps']])\n a[i]['seg_areas'] = np.hstack((a[i]['seg_areas'],\n b[i]['seg_areas']))\n return a\n\n def competition_mode(self, on):\n \"\"\"Turn competition mode on or off.\"\"\"\n pass\n" }, { "path": "lib/datasets/pascal_voc.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport os\nfrom datasets.imdb import imdb\nimport datasets.ds_utils as ds_utils\nimport xml.etree.ElementTree as ET\nimport numpy as np\nimport scipy.sparse\nimport scipy.io as sio\nimport utils.cython_bbox\nimport cPickle\nimport subprocess\nimport uuid\nfrom voc_eval import voc_eval\nfrom fast_rcnn.config import cfg\n\nclass pascal_voc(imdb):\n def __init__(self, image_set, year, devkit_path=None):\n imdb.__init__(self, 'voc_' + year + '_' + image_set)\n self._year = year\n self._image_set = image_set\n self._devkit_path = self._get_default_path() if devkit_path is None \\\n else devkit_path\n self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)\n self._classes = ('__background__', # always index 0\n 'aeroplane', 'bicycle', 'bird', 'boat',\n 'bottle', 'bus', 'car', 'cat', 'chair',\n 'cow', 'diningtable', 'dog', 'horse',\n 'motorbike', 'person', 'pottedplant',\n 'sheep', 'sofa', 'train', 'tvmonitor')\n self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))\n self._image_ext = '.jpg'\n self._image_index = self._load_image_set_index()\n # Default to roidb handler\n self._roidb_handler = self.selective_search_roidb\n self._salt = str(uuid.uuid4())\n self._comp_id = 'comp4'\n\n # PASCAL specific config options\n self.config = {'cleanup' : True,\n 'use_salt' : True,\n 'use_diff' : False,\n 'matlab_eval' : False,\n 'rpn_file' : None,\n 'min_size' : 2}\n\n assert os.path.exists(self._devkit_path), \\\n 'VOCdevkit path does not exist: {}'.format(self._devkit_path)\n assert os.path.exists(self._data_path), \\\n 'Path does not exist: {}'.format(self._data_path)\n\n def image_path_at(self, i):\n \"\"\"\n Return the absolute path to image i in the image sequence.\n \"\"\"\n return self.image_path_from_index(self._image_index[i])\n\n def image_path_from_index(self, index):\n \"\"\"\n Construct an image path from the image's \"index\" identifier.\n \"\"\"\n image_path = os.path.join(self._data_path, 'JPEGImages',\n index + self._image_ext)\n assert os.path.exists(image_path), \\\n 'Path does not exist: {}'.format(image_path)\n return image_path\n\n def _load_image_set_index(self):\n \"\"\"\n Load the indexes listed in this dataset's image set file.\n \"\"\"\n # Example path to image set file:\n # self._devkit_path + /VOCdevkit2007/VOC2007/ImageSets/Main/val.txt\n image_set_file = os.path.join(self._data_path, 'ImageSets', 'Main',\n self._image_set + '.txt')\n assert os.path.exists(image_set_file), \\\n 'Path does not exist: {}'.format(image_set_file)\n with open(image_set_file) as f:\n image_index = [x.strip() for x in f.readlines()]\n return image_index\n\n def _get_default_path(self):\n \"\"\"\n Return the default path where PASCAL VOC is expected to be installed.\n \"\"\"\n return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year)\n\n def gt_roidb(self):\n \"\"\"\n Return the database of ground-truth regions of interest.\n\n This function loads/saves from/to a cache file to speed up future calls.\n \"\"\"\n cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl')\n if os.path.exists(cache_file):\n with open(cache_file, 'rb') as fid:\n roidb = cPickle.load(fid)\n print '{} gt roidb loaded from {}'.format(self.name, cache_file)\n return roidb\n\n gt_roidb = [self._load_pascal_annotation(index)\n for index in self.image_index]\n with open(cache_file, 'wb') as fid:\n cPickle.dump(gt_roidb, fid, cPickle.HIGHEST_PROTOCOL)\n print 'wrote gt roidb to {}'.format(cache_file)\n\n return gt_roidb\n\n def selective_search_roidb(self):\n \"\"\"\n Return the database of selective search regions of interest.\n Ground-truth ROIs are also included.\n\n This function loads/saves from/to a cache file to speed up future calls.\n \"\"\"\n cache_file = os.path.join(self.cache_path,\n self.name + '_selective_search_roidb.pkl')\n\n if os.path.exists(cache_file):\n with open(cache_file, 'rb') as fid:\n roidb = cPickle.load(fid)\n print '{} ss roidb loaded from {}'.format(self.name, cache_file)\n return roidb\n\n if int(self._year) == 2007 or self._image_set != 'test':\n gt_roidb = self.gt_roidb()\n ss_roidb = self._load_selective_search_roidb(gt_roidb)\n roidb = imdb.merge_roidbs(gt_roidb, ss_roidb)\n else:\n roidb = self._load_selective_search_roidb(None)\n with open(cache_file, 'wb') as fid:\n cPickle.dump(roidb, fid, cPickle.HIGHEST_PROTOCOL)\n print 'wrote ss roidb to {}'.format(cache_file)\n\n return roidb\n\n def rpn_roidb(self):\n if int(self._year) == 2007 or self._image_set != 'test':\n gt_roidb = self.gt_roidb()\n rpn_roidb = self._load_rpn_roidb(gt_roidb)\n roidb = imdb.merge_roidbs(gt_roidb, rpn_roidb)\n else:\n roidb = self._load_rpn_roidb(None)\n\n return roidb\n\n def _load_rpn_roidb(self, gt_roidb):\n filename = self.config['rpn_file']\n print 'loading {}'.format(filename)\n assert os.path.exists(filename), \\\n 'rpn data not found at: {}'.format(filename)\n with open(filename, 'rb') as f:\n box_list = cPickle.load(f)\n return self.create_roidb_from_box_list(box_list, gt_roidb)\n\n def _load_selective_search_roidb(self, gt_roidb):\n filename = os.path.abspath(os.path.join(cfg.DATA_DIR,\n 'selective_search_data',\n self.name + '.mat'))\n assert os.path.exists(filename), \\\n 'Selective search data not found at: {}'.format(filename)\n raw_data = sio.loadmat(filename)['boxes'].ravel()\n\n box_list = []\n for i in xrange(raw_data.shape[0]):\n boxes = raw_data[i][:, (1, 0, 3, 2)] - 1\n keep = ds_utils.unique_boxes(boxes)\n boxes = boxes[keep, :]\n keep = ds_utils.filter_small_boxes(boxes, self.config['min_size'])\n boxes = boxes[keep, :]\n box_list.append(boxes)\n\n return self.create_roidb_from_box_list(box_list, gt_roidb)\n\n def _load_pascal_annotation(self, index):\n \"\"\"\n Load image and bounding boxes info from XML file in the PASCAL VOC\n format.\n \"\"\"\n filename = os.path.join(self._data_path, 'Annotations', index + '.xml')\n tree = ET.parse(filename)\n objs = tree.findall('object')\n if not self.config['use_diff']:\n # Exclude the samples labeled as difficult\n non_diff_objs = [\n obj for obj in objs if int(obj.find('difficult').text) == 0]\n # if len(non_diff_objs) != len(objs):\n # print 'Removed {} difficult objects'.format(\n # len(objs) - len(non_diff_objs))\n objs = non_diff_objs\n num_objs = len(objs)\n\n boxes = np.zeros((num_objs, 4), dtype=np.uint16)\n gt_classes = np.zeros((num_objs), dtype=np.int32)\n overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\n # \"Seg\" area for pascal is just the box area\n seg_areas = np.zeros((num_objs), dtype=np.float32)\n\n # Load object bounding boxes into a data frame.\n for ix, obj in enumerate(objs):\n bbox = obj.find('bndbox')\n # Make pixel indexes 0-based\n x1 = float(bbox.find('xmin').text) - 1\n y1 = float(bbox.find('ymin').text) - 1\n x2 = float(bbox.find('xmax').text) - 1\n y2 = float(bbox.find('ymax').text) - 1\n cls = self._class_to_ind[obj.find('name').text.lower().strip()]\n boxes[ix, :] = [x1, y1, x2, y2]\n gt_classes[ix] = cls\n overlaps[ix, cls] = 1.0\n seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\n\n overlaps = scipy.sparse.csr_matrix(overlaps)\n\n return {'boxes' : boxes,\n 'gt_classes': gt_classes,\n 'gt_overlaps' : overlaps,\n 'flipped' : False,\n 'seg_areas' : seg_areas}\n\n def _get_comp_id(self):\n comp_id = (self._comp_id + '_' + self._salt if self.config['use_salt']\n else self._comp_id)\n return comp_id\n\n def _get_voc_results_file_template(self):\n # VOCdevkit/results/VOC2007/Main/_det_test_aeroplane.txt\n filename = self._get_comp_id() + '_det_' + self._image_set + '_{:s}.txt'\n path = os.path.join(\n self._devkit_path,\n 'results',\n 'VOC' + self._year,\n 'Main',\n filename)\n return path\n\n def _write_voc_results_file(self, all_boxes):\n for cls_ind, cls in enumerate(self.classes):\n if cls == '__background__':\n continue\n print 'Writing {} VOC results file'.format(cls)\n filename = self._get_voc_results_file_template().format(cls)\n with open(filename, 'wt') as f:\n for im_ind, index in enumerate(self.image_index):\n dets = all_boxes[cls_ind][im_ind]\n if dets == []:\n continue\n # the VOCdevkit expects 1-based indices\n for k in xrange(dets.shape[0]):\n f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\\n'.\n format(index, dets[k, -1],\n dets[k, 0] + 1, dets[k, 1] + 1,\n dets[k, 2] + 1, dets[k, 3] + 1))\n\n def _do_python_eval(self, output_dir = 'output'):\n annopath = os.path.join(\n self._devkit_path,\n 'VOC' + self._year,\n 'Annotations',\n '{:s}.xml')\n imagesetfile = os.path.join(\n self._devkit_path,\n 'VOC' + self._year,\n 'ImageSets',\n 'Main',\n self._image_set + '.txt')\n cachedir = os.path.join(self._devkit_path, 'annotations_cache')\n aps = []\n # The PASCAL VOC metric changed in 2010\n use_07_metric = True if int(self._year) < 2010 else False\n print 'VOC07 metric? ' + ('Yes' if use_07_metric else 'No')\n if not os.path.isdir(output_dir):\n os.mkdir(output_dir)\n for i, cls in enumerate(self._classes):\n if cls == '__background__':\n continue\n filename = self._get_voc_results_file_template().format(cls)\n rec, prec, ap = voc_eval(\n filename, annopath, imagesetfile, cls, cachedir, ovthresh=0.5,\n use_07_metric=use_07_metric)\n aps += [ap]\n print('AP for {} = {:.4f}'.format(cls, ap))\n with open(os.path.join(output_dir, cls + '_pr.pkl'), 'w') as f:\n cPickle.dump({'rec': rec, 'prec': prec, 'ap': ap}, f)\n print('Mean AP = {:.4f}'.format(np.mean(aps)))\n print('~~~~~~~~')\n print('Results:')\n for ap in aps:\n print('{:.3f}'.format(ap))\n print('{:.3f}'.format(np.mean(aps)))\n print('~~~~~~~~')\n print('')\n print('--------------------------------------------------------------')\n print('Results computed with the **unofficial** Python eval code.')\n print('Results should be very close to the official MATLAB eval code.')\n print('Recompute with `./tools/reval.py --matlab ...` for your paper.')\n print('-- Thanks, The Management')\n print('--------------------------------------------------------------')\n\n def _do_matlab_eval(self, output_dir='output'):\n print '-----------------------------------------------------'\n print 'Computing results with the official MATLAB eval code.'\n print '-----------------------------------------------------'\n path = os.path.join(cfg.ROOT_DIR, 'lib', 'datasets',\n 'VOCdevkit-matlab-wrapper')\n cmd = 'cd {} && '.format(path)\n cmd += '{:s} -nodisplay -nodesktop '.format(cfg.MATLAB)\n cmd += '-r \"dbstop if error; '\n cmd += 'voc_eval(\\'{:s}\\',\\'{:s}\\',\\'{:s}\\',\\'{:s}\\'); quit;\"' \\\n .format(self._devkit_path, self._get_comp_id(),\n self._image_set, output_dir)\n print('Running:\\n{}'.format(cmd))\n status = subprocess.call(cmd, shell=True)\n\n def evaluate_detections(self, all_boxes, output_dir):\n self._write_voc_results_file(all_boxes)\n self._do_python_eval(output_dir)\n if self.config['matlab_eval']:\n self._do_matlab_eval(output_dir)\n if self.config['cleanup']:\n for cls in self._classes:\n if cls == '__background__':\n continue\n filename = self._get_voc_results_file_template().format(cls)\n os.remove(filename)\n\n def competition_mode(self, on):\n if on:\n self.config['use_salt'] = False\n self.config['cleanup'] = False\n else:\n self.config['use_salt'] = True\n self.config['cleanup'] = True\n\nif __name__ == '__main__':\n from datasets.pascal_voc import pascal_voc\n d = pascal_voc('trainval', '2007')\n res = d.roidb\n from IPython import embed; embed()\n" }, { "path": "lib/datasets/tools/mcg_munge.py", "content": "import os\nimport sys\n\n\"\"\"Hacky tool to convert file system layout of MCG boxes downloaded from\nhttp://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/mcg/\nso that it's consistent with those computed by Jan Hosang (see:\nhttp://www.mpi-inf.mpg.de/departments/computer-vision-and-multimodal-\n computing/research/object-recognition-and-scene-understanding/how-\n good-are-detection-proposals-really/)\n\nNB: Boxes from the MCG website are in (y1, x1, y2, x2) order.\nBoxes from Hosang et al. are in (x1, y1, x2, y2) order.\n\"\"\"\n\ndef munge(src_dir):\n # stored as: ./MCG-COCO-val2014-boxes/COCO_val2014_000000193401.mat\n # want: ./MCG/mat/COCO_val2014_0/COCO_val2014_000000141/COCO_val2014_000000141334.mat\n\n files = os.listdir(src_dir)\n for fn in files:\n base, ext = os.path.splitext(fn)\n # first 14 chars / first 22 chars / all chars + .mat\n # COCO_val2014_0/COCO_val2014_000000447/COCO_val2014_000000447991.mat\n first = base[:14]\n second = base[:22]\n dst_dir = os.path.join('MCG', 'mat', first, second)\n if not os.path.exists(dst_dir):\n os.makedirs(dst_dir)\n src = os.path.join(src_dir, fn)\n dst = os.path.join(dst_dir, fn)\n print 'MV: {} -> {}'.format(src, dst)\n os.rename(src, dst)\n\nif __name__ == '__main__':\n # src_dir should look something like:\n # src_dir = 'MCG-COCO-val2014-boxes'\n src_dir = sys.argv[1]\n munge(src_dir)\n" }, { "path": "lib/datasets/voc_eval.py", "content": "# --------------------------------------------------------\n# Fast/er R-CNN\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Bharath Hariharan\n# --------------------------------------------------------\n\nimport xml.etree.ElementTree as ET\nimport os\nimport cPickle\nimport numpy as np\n\ndef parse_rec(filename):\n \"\"\" Parse a PASCAL VOC xml file \"\"\"\n tree = ET.parse(filename)\n objects = []\n for obj in tree.findall('object'):\n obj_struct = {}\n obj_struct['name'] = obj.find('name').text\n obj_struct['pose'] = obj.find('pose').text\n obj_struct['truncated'] = int(obj.find('truncated').text)\n obj_struct['difficult'] = int(obj.find('difficult').text)\n bbox = obj.find('bndbox')\n obj_struct['bbox'] = [int(bbox.find('xmin').text),\n int(bbox.find('ymin').text),\n int(bbox.find('xmax').text),\n int(bbox.find('ymax').text)]\n objects.append(obj_struct)\n\n return objects\n\ndef voc_ap(rec, prec, use_07_metric=False):\n \"\"\" ap = voc_ap(rec, prec, [use_07_metric])\n Compute VOC AP given precision and recall.\n If use_07_metric is true, uses the\n VOC 07 11 point method (default:False).\n \"\"\"\n if use_07_metric:\n # 11 point metric\n ap = 0.\n for t in np.arange(0., 1.1, 0.1):\n if np.sum(rec >= t) == 0:\n p = 0\n else:\n p = np.max(prec[rec >= t])\n ap = ap + p / 11.\n else:\n # correct AP calculation\n # first append sentinel values at the end\n mrec = np.concatenate(([0.], rec, [1.]))\n mpre = np.concatenate(([0.], prec, [0.]))\n\n # compute the precision envelope\n for i in range(mpre.size - 1, 0, -1):\n mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])\n\n # to calculate area under PR curve, look for points\n # where X axis (recall) changes value\n i = np.where(mrec[1:] != mrec[:-1])[0]\n\n # and sum (\\Delta recall) * prec\n ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])\n return ap\n\ndef voc_eval(detpath,\n annopath,\n imagesetfile,\n classname,\n cachedir,\n ovthresh=0.5,\n use_07_metric=False):\n \"\"\"rec, prec, ap = voc_eval(detpath,\n annopath,\n imagesetfile,\n classname,\n [ovthresh],\n [use_07_metric])\n\n Top level function that does the PASCAL VOC evaluation.\n\n detpath: Path to detections\n detpath.format(classname) should produce the detection results file.\n annopath: Path to annotations\n annopath.format(imagename) should be the xml annotations file.\n imagesetfile: Text file containing the list of images, one image per line.\n classname: Category name (duh)\n cachedir: Directory for caching the annotations\n [ovthresh]: Overlap threshold (default = 0.5)\n [use_07_metric]: Whether to use VOC07's 11 point AP computation\n (default False)\n \"\"\"\n # assumes detections are in detpath.format(classname)\n # assumes annotations are in annopath.format(imagename)\n # assumes imagesetfile is a text file with each line an image name\n # cachedir caches the annotations in a pickle file\n\n # first load gt\n if not os.path.isdir(cachedir):\n os.mkdir(cachedir)\n cachefile = os.path.join(cachedir, 'annots.pkl')\n # read list of images\n with open(imagesetfile, 'r') as f:\n lines = f.readlines()\n imagenames = [x.strip() for x in lines]\n\n if not os.path.isfile(cachefile):\n # load annots\n recs = {}\n for i, imagename in enumerate(imagenames):\n recs[imagename] = parse_rec(annopath.format(imagename))\n if i % 100 == 0:\n print 'Reading annotation for {:d}/{:d}'.format(\n i + 1, len(imagenames))\n # save\n print 'Saving cached annotations to {:s}'.format(cachefile)\n with open(cachefile, 'w') as f:\n cPickle.dump(recs, f)\n else:\n # load\n with open(cachefile, 'r') as f:\n recs = cPickle.load(f)\n\n # extract gt objects for this class\n class_recs = {}\n npos = 0\n for imagename in imagenames:\n R = [obj for obj in recs[imagename] if obj['name'] == classname]\n bbox = np.array([x['bbox'] for x in R])\n difficult = np.array([x['difficult'] for x in R]).astype(np.bool)\n det = [False] * len(R)\n npos = npos + sum(~difficult)\n class_recs[imagename] = {'bbox': bbox,\n 'difficult': difficult,\n 'det': det}\n\n # read dets\n detfile = detpath.format(classname)\n with open(detfile, 'r') as f:\n lines = f.readlines()\n\n splitlines = [x.strip().split(' ') for x in lines]\n image_ids = [x[0] for x in splitlines]\n confidence = np.array([float(x[1]) for x in splitlines])\n BB = np.array([[float(z) for z in x[2:]] for x in splitlines])\n\n # sort by confidence\n sorted_ind = np.argsort(-confidence)\n sorted_scores = np.sort(-confidence)\n BB = BB[sorted_ind, :]\n image_ids = [image_ids[x] for x in sorted_ind]\n\n # go down dets and mark TPs and FPs\n nd = len(image_ids)\n tp = np.zeros(nd)\n fp = np.zeros(nd)\n for d in range(nd):\n R = class_recs[image_ids[d]]\n bb = BB[d, :].astype(float)\n ovmax = -np.inf\n BBGT = R['bbox'].astype(float)\n\n if BBGT.size > 0:\n # compute overlaps\n # intersection\n ixmin = np.maximum(BBGT[:, 0], bb[0])\n iymin = np.maximum(BBGT[:, 1], bb[1])\n ixmax = np.minimum(BBGT[:, 2], bb[2])\n iymax = np.minimum(BBGT[:, 3], bb[3])\n iw = np.maximum(ixmax - ixmin + 1., 0.)\n ih = np.maximum(iymax - iymin + 1., 0.)\n inters = iw * ih\n\n # union\n uni = ((bb[2] - bb[0] + 1.) * (bb[3] - bb[1] + 1.) +\n (BBGT[:, 2] - BBGT[:, 0] + 1.) *\n (BBGT[:, 3] - BBGT[:, 1] + 1.) - inters)\n\n overlaps = inters / uni\n ovmax = np.max(overlaps)\n jmax = np.argmax(overlaps)\n\n if ovmax > ovthresh:\n if not R['difficult'][jmax]:\n if not R['det'][jmax]:\n tp[d] = 1.\n R['det'][jmax] = 1\n else:\n fp[d] = 1.\n else:\n fp[d] = 1.\n\n # compute precision recall\n fp = np.cumsum(fp)\n tp = np.cumsum(tp)\n rec = tp / float(npos)\n # avoid divide by zero in case the first detection matches a difficult\n # ground truth\n prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)\n ap = voc_ap(rec, prec, use_07_metric)\n\n return rec, prec, ap\n" }, { "path": "lib/fast_rcnn/__init__.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n" }, { "path": "lib/fast_rcnn/bbox_transform.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport numpy as np\n\ndef bbox_transform(ex_rois, gt_rois):\n ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0\n ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0\n ex_ctr_x = ex_rois[:, 0] + 0.5 * ex_widths\n ex_ctr_y = ex_rois[:, 1] + 0.5 * ex_heights\n\n gt_widths = gt_rois[:, 2] - gt_rois[:, 0] + 1.0\n gt_heights = gt_rois[:, 3] - gt_rois[:, 1] + 1.0\n gt_ctr_x = gt_rois[:, 0] + 0.5 * gt_widths\n gt_ctr_y = gt_rois[:, 1] + 0.5 * gt_heights\n\n targets_dx = (gt_ctr_x - ex_ctr_x) / ex_widths\n targets_dy = (gt_ctr_y - ex_ctr_y) / ex_heights\n targets_dw = np.log(gt_widths / ex_widths)\n targets_dh = np.log(gt_heights / ex_heights)\n\n targets = np.vstack(\n (targets_dx, targets_dy, targets_dw, targets_dh)).transpose()\n return targets\n\ndef bbox_transform_inv(boxes, deltas):\n if boxes.shape[0] == 0:\n return np.zeros((0, deltas.shape[1]), dtype=deltas.dtype)\n\n boxes = boxes.astype(deltas.dtype, copy=False)\n\n widths = boxes[:, 2] - boxes[:, 0] + 1.0\n heights = boxes[:, 3] - boxes[:, 1] + 1.0\n ctr_x = boxes[:, 0] + 0.5 * widths\n ctr_y = boxes[:, 1] + 0.5 * heights\n\n dx = deltas[:, 0::4]\n dy = deltas[:, 1::4]\n dw = deltas[:, 2::4]\n dh = deltas[:, 3::4]\n\n pred_ctr_x = dx * widths[:, np.newaxis] + ctr_x[:, np.newaxis]\n pred_ctr_y = dy * heights[:, np.newaxis] + ctr_y[:, np.newaxis]\n pred_w = np.exp(dw) * widths[:, np.newaxis]\n pred_h = np.exp(dh) * heights[:, np.newaxis]\n\n pred_boxes = np.zeros(deltas.shape, dtype=deltas.dtype)\n # x1\n pred_boxes[:, 0::4] = pred_ctr_x - 0.5 * pred_w\n # y1\n pred_boxes[:, 1::4] = pred_ctr_y - 0.5 * pred_h\n # x2\n pred_boxes[:, 2::4] = pred_ctr_x + 0.5 * pred_w\n # y2\n pred_boxes[:, 3::4] = pred_ctr_y + 0.5 * pred_h\n\n return pred_boxes\n\ndef clip_boxes(boxes, im_shape):\n \"\"\"\n Clip boxes to image boundaries.\n \"\"\"\n\n # x1 >= 0\n boxes[:, 0::4] = np.maximum(np.minimum(boxes[:, 0::4], im_shape[1] - 1), 0)\n # y1 >= 0\n boxes[:, 1::4] = np.maximum(np.minimum(boxes[:, 1::4], im_shape[0] - 1), 0)\n # x2 < im_shape[1]\n boxes[:, 2::4] = np.maximum(np.minimum(boxes[:, 2::4], im_shape[1] - 1), 0)\n # y2 < im_shape[0]\n boxes[:, 3::4] = np.maximum(np.minimum(boxes[:, 3::4], im_shape[0] - 1), 0)\n return boxes\n" }, { "path": "lib/fast_rcnn/config.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Fast R-CNN config system.\n\nThis file specifies default config options for Fast R-CNN. You should not\nchange values in this file. Instead, you should write a config file (in yaml)\nand use cfg_from_file(yaml_file) to load it and override the default options.\n\nMost tools in $ROOT/tools take a --cfg option to specify an override file.\n - See tools/{train,test}_net.py for example code that uses cfg_from_file()\n - See experiments/cfgs/*.yml for example YAML config override files\n\"\"\"\n\nimport os\nimport os.path as osp\nimport numpy as np\n# `pip install easydict` if you don't have it\nfrom easydict import EasyDict as edict\n\n__C = edict()\n# Consumers can get config by:\n# from fast_rcnn_config import cfg\ncfg = __C\n\n#\n# Training options\n#\n\n__C.TRAIN = edict()\n\n# Scales to use during training (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TRAIN.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TRAIN.MAX_SIZE = 1000\n\n# Images to use per minibatch\n__C.TRAIN.IMS_PER_BATCH = 2\n\n# Minibatch size (number of regions of interest [ROIs])\n__C.TRAIN.BATCH_SIZE = 128\n\n# Fraction of minibatch that is labeled foreground (i.e. class > 0)\n__C.TRAIN.FG_FRACTION = 0.25\n\n# Overlap threshold for a ROI to be considered foreground (if >= FG_THRESH)\n__C.TRAIN.FG_THRESH = 0.5\n\n# Overlap threshold for a ROI to be considered background (class = 0 if\n# overlap in [LO, HI))\n__C.TRAIN.BG_THRESH_HI = 0.5\n__C.TRAIN.BG_THRESH_LO = 0.1\n\n# Use horizontally-flipped images during training?\n__C.TRAIN.USE_FLIPPED = True\n\n# Train bounding-box regressors\n__C.TRAIN.BBOX_REG = True\n\n# Overlap required between a ROI and ground-truth box in order for that ROI to\n# be used as a bounding-box regression training example\n__C.TRAIN.BBOX_THRESH = 0.5\n\n# Iterations between snapshots\n__C.TRAIN.SNAPSHOT_ITERS = 10000\n\n# solver.prototxt specifies the snapshot path prefix, this adds an optional\n# infix to yield the path: [_]_iters_XYZ.caffemodel\n__C.TRAIN.SNAPSHOT_INFIX = ''\n\n# Use a prefetch thread in roi_data_layer.layer\n# So far I haven't found this useful; likely more engineering work is required\n__C.TRAIN.USE_PREFETCH = False\n\n# Normalize the targets (subtract empirical mean, divide by empirical stddev)\n__C.TRAIN.BBOX_NORMALIZE_TARGETS = True\n# Deprecated (inside weights)\n__C.TRAIN.BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0)\n# Normalize the targets using \"precomputed\" (or made up) means and stdevs\n# (BBOX_NORMALIZE_TARGETS must also be True)\n__C.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED = False\n__C.TRAIN.BBOX_NORMALIZE_MEANS = (0.0, 0.0, 0.0, 0.0)\n__C.TRAIN.BBOX_NORMALIZE_STDS = (0.1, 0.1, 0.2, 0.2)\n\n# Train using these proposals\n__C.TRAIN.PROPOSAL_METHOD = 'selective_search'\n\n# Make minibatches from images that have similar aspect ratios (i.e. both\n# tall and thin or both short and wide) in order to avoid wasting computation\n# on zero-padding.\n__C.TRAIN.ASPECT_GROUPING = True\n\n# Use RPN to detect objects\n__C.TRAIN.HAS_RPN = False\n# IOU >= thresh: positive example\n__C.TRAIN.RPN_POSITIVE_OVERLAP = 0.7\n# IOU < thresh: negative example\n__C.TRAIN.RPN_NEGATIVE_OVERLAP = 0.3\n# If an anchor statisfied by positive and negative conditions set to negative\n__C.TRAIN.RPN_CLOBBER_POSITIVES = False\n# Max number of foreground examples\n__C.TRAIN.RPN_FG_FRACTION = 0.5\n# Total number of examples\n__C.TRAIN.RPN_BATCHSIZE = 256\n# NMS threshold used on RPN proposals\n__C.TRAIN.RPN_NMS_THRESH = 0.7\n# Number of top scoring boxes to keep before apply NMS to RPN proposals\n__C.TRAIN.RPN_PRE_NMS_TOP_N = 12000\n# Number of top scoring boxes to keep after applying NMS to RPN proposals\n__C.TRAIN.RPN_POST_NMS_TOP_N = 2000\n# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale)\n__C.TRAIN.RPN_MIN_SIZE = 16\n# Deprecated (outside weights)\n__C.TRAIN.RPN_BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0)\n# Give the positive RPN examples weight of p * 1 / {num positives}\n# and give negatives a weight of (1 - p)\n# Set to -1.0 to use uniform example weighting\n__C.TRAIN.RPN_POSITIVE_WEIGHT = -1.0\n\n\n#\n# Testing options\n#\n\n__C.TEST = edict()\n\n# Scales to use during testing (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TEST.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TEST.MAX_SIZE = 1000\n\n# Overlap threshold used for non-maximum suppression (suppress boxes with\n# IoU >= this threshold)\n__C.TEST.NMS = 0.3\n\n# Experimental: treat the (K+1) units in the cls_score layer as linear\n# predictors (trained, eg, with one-vs-rest SVMs).\n__C.TEST.SVM = False\n\n# Test using bounding-box regressors\n__C.TEST.BBOX_REG = True\n\n# Propose boxes\n__C.TEST.HAS_RPN = False\n\n# Test using these proposals\n__C.TEST.PROPOSAL_METHOD = 'selective_search'\n\n## NMS threshold used on RPN proposals\n__C.TEST.RPN_NMS_THRESH = 0.7\n## Number of top scoring boxes to keep before apply NMS to RPN proposals\n__C.TEST.RPN_PRE_NMS_TOP_N = 6000\n## Number of top scoring boxes to keep after applying NMS to RPN proposals\n__C.TEST.RPN_POST_NMS_TOP_N = 300\n# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale)\n__C.TEST.RPN_MIN_SIZE = 16\n\n\n#\n# MISC\n#\n\n# The mapping from image coordinates to feature map coordinates might cause\n# some boxes that are distinct in image space to become identical in feature\n# coordinates. If DEDUP_BOXES > 0, then DEDUP_BOXES is used as the scale factor\n# for identifying duplicate boxes.\n# 1/16 is correct for {Alex,Caffe}Net, VGG_CNN_M_1024, and VGG16\n__C.DEDUP_BOXES = 1./16.\n\n# Pixel mean values (BGR order) as a (1, 1, 3) array\n# We use the same pixel mean for all networks even though it's not exactly what\n# they were trained with\n__C.PIXEL_MEANS = np.array([[[102.9801, 115.9465, 122.7717]]])\n\n# For reproducibility\n__C.RNG_SEED = 3\n\n# A small number that's used many times\n__C.EPS = 1e-14\n\n# Root directory of project\n__C.ROOT_DIR = osp.abspath(osp.join(osp.dirname(__file__), '..', '..'))\n\n# Data directory\n__C.DATA_DIR = osp.abspath(osp.join(__C.ROOT_DIR, 'data'))\n\n# Model directory\n__C.MODELS_DIR = osp.abspath(osp.join(__C.ROOT_DIR, 'models', 'pascal_voc'))\n\n# Name (or path to) the matlab executable\n__C.MATLAB = 'matlab'\n\n# Place outputs under an experiments directory\n__C.EXP_DIR = 'default'\n\n# Use GPU implementation of non-maximum suppression\n__C.USE_GPU_NMS = True\n\n# Default GPU device id\n__C.GPU_ID = 0\n\n\ndef get_output_dir(imdb, net=None):\n \"\"\"Return the directory where experimental artifacts are placed.\n If the directory does not exist, it is created.\n\n A canonical path is built using the name from an imdb and a network\n (if not None).\n \"\"\"\n outdir = osp.abspath(osp.join(__C.ROOT_DIR, 'output', __C.EXP_DIR, imdb.name))\n if net is not None:\n outdir = osp.join(outdir, net.name)\n if not os.path.exists(outdir):\n os.makedirs(outdir)\n return outdir\n\ndef _merge_a_into_b(a, b):\n \"\"\"Merge config dictionary a into config dictionary b, clobbering the\n options in b whenever they are also specified in a.\n \"\"\"\n if type(a) is not edict:\n return\n\n for k, v in a.iteritems():\n # a must specify keys that are in b\n if not b.has_key(k):\n raise KeyError('{} is not a valid config key'.format(k))\n\n # the types must match, too\n old_type = type(b[k])\n if old_type is not type(v):\n if isinstance(b[k], np.ndarray):\n v = np.array(v, dtype=b[k].dtype)\n else:\n raise ValueError(('Type mismatch ({} vs. {}) '\n 'for config key: {}').format(type(b[k]),\n type(v), k))\n\n # recursively merge dicts\n if type(v) is edict:\n try:\n _merge_a_into_b(a[k], b[k])\n except:\n print('Error under config key: {}'.format(k))\n raise\n else:\n b[k] = v\n\ndef cfg_from_file(filename):\n \"\"\"Load a config file and merge it into the default options.\"\"\"\n import yaml\n with open(filename, 'r') as f:\n yaml_cfg = edict(yaml.load(f))\n\n _merge_a_into_b(yaml_cfg, __C)\n\ndef cfg_from_list(cfg_list):\n \"\"\"Set config keys via list (e.g., from command line).\"\"\"\n from ast import literal_eval\n assert len(cfg_list) % 2 == 0\n for k, v in zip(cfg_list[0::2], cfg_list[1::2]):\n key_list = k.split('.')\n d = __C\n for subkey in key_list[:-1]:\n assert d.has_key(subkey)\n d = d[subkey]\n subkey = key_list[-1]\n assert d.has_key(subkey)\n try:\n value = literal_eval(v)\n except:\n # handle the case when v is a string literal\n value = v\n assert type(value) == type(d[subkey]), \\\n 'type {} does not match original type {}'.format(\n type(value), type(d[subkey]))\n d[subkey] = value\n" }, { "path": "lib/fast_rcnn/nms_wrapper.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nfrom fast_rcnn.config import cfg\nfrom nms.gpu_nms import gpu_nms\nfrom nms.cpu_nms import cpu_nms\n\ndef nms(dets, thresh, force_cpu=False):\n \"\"\"Dispatch to either CPU or GPU NMS implementations.\"\"\"\n\n if dets.shape[0] == 0:\n return []\n if cfg.USE_GPU_NMS and not force_cpu:\n return gpu_nms(dets, thresh, device_id=cfg.GPU_ID)\n else:\n return cpu_nms(dets, thresh)\n" }, { "path": "lib/fast_rcnn/test.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Test a Fast R-CNN network on an imdb (image database).\"\"\"\n\nfrom fast_rcnn.config import cfg, get_output_dir\nfrom fast_rcnn.bbox_transform import clip_boxes, bbox_transform_inv\nimport argparse\nfrom utils.timer import Timer\nimport numpy as np\nimport cv2\nimport caffe\nfrom fast_rcnn.nms_wrapper import nms\nimport cPickle\nfrom utils.blob import im_list_to_blob\nimport os\n\ndef _get_image_blob(im):\n \"\"\"Converts an image into a network input.\n\n Arguments:\n im (ndarray): a color image in BGR order\n\n Returns:\n blob (ndarray): a data blob holding an image pyramid\n im_scale_factors (list): list of image scales (relative to im) used\n in the image pyramid\n \"\"\"\n im_orig = im.astype(np.float32, copy=True)\n im_orig -= cfg.PIXEL_MEANS\n\n im_shape = im_orig.shape\n im_size_min = np.min(im_shape[0:2])\n im_size_max = np.max(im_shape[0:2])\n\n processed_ims = []\n im_scale_factors = []\n\n for target_size in cfg.TEST.SCALES:\n im_scale = float(target_size) / float(im_size_min)\n # Prevent the biggest axis from being more than MAX_SIZE\n if np.round(im_scale * im_size_max) > cfg.TEST.MAX_SIZE:\n im_scale = float(cfg.TEST.MAX_SIZE) / float(im_size_max)\n im = cv2.resize(im_orig, None, None, fx=im_scale, fy=im_scale,\n interpolation=cv2.INTER_LINEAR)\n im_scale_factors.append(im_scale)\n processed_ims.append(im)\n\n # Create a blob to hold the input images\n blob = im_list_to_blob(processed_ims)\n\n return blob, np.array(im_scale_factors)\n\ndef _get_rois_blob(im_rois, im_scale_factors):\n \"\"\"Converts RoIs into network inputs.\n\n Arguments:\n im_rois (ndarray): R x 4 matrix of RoIs in original image coordinates\n im_scale_factors (list): scale factors as returned by _get_image_blob\n\n Returns:\n blob (ndarray): R x 5 matrix of RoIs in the image pyramid\n \"\"\"\n rois, levels = _project_im_rois(im_rois, im_scale_factors)\n rois_blob = np.hstack((levels, rois))\n return rois_blob.astype(np.float32, copy=False)\n\ndef _project_im_rois(im_rois, scales):\n \"\"\"Project image RoIs into the image pyramid built by _get_image_blob.\n\n Arguments:\n im_rois (ndarray): R x 4 matrix of RoIs in original image coordinates\n scales (list): scale factors as returned by _get_image_blob\n\n Returns:\n rois (ndarray): R x 4 matrix of projected RoI coordinates\n levels (list): image pyramid levels used by each projected RoI\n \"\"\"\n im_rois = im_rois.astype(np.float, copy=False)\n\n if len(scales) > 1:\n widths = im_rois[:, 2] - im_rois[:, 0] + 1\n heights = im_rois[:, 3] - im_rois[:, 1] + 1\n\n areas = widths * heights\n scaled_areas = areas[:, np.newaxis] * (scales[np.newaxis, :] ** 2)\n diff_areas = np.abs(scaled_areas - 224 * 224)\n levels = diff_areas.argmin(axis=1)[:, np.newaxis]\n else:\n levels = np.zeros((im_rois.shape[0], 1), dtype=np.int)\n\n rois = im_rois * scales[levels]\n\n return rois, levels\n\ndef _get_blobs(im, rois):\n \"\"\"Convert an image and RoIs within that image into network inputs.\"\"\"\n blobs = {'data' : None, 'rois' : None}\n blobs['data'], im_scale_factors = _get_image_blob(im)\n if not cfg.TEST.HAS_RPN:\n blobs['rois'] = _get_rois_blob(rois, im_scale_factors)\n return blobs, im_scale_factors\n\ndef im_detect(net, im, boxes=None):\n \"\"\"Detect object classes in an image given object proposals.\n\n Arguments:\n net (caffe.Net): Fast R-CNN network to use\n im (ndarray): color image to test (in BGR order)\n boxes (ndarray): R x 4 array of object proposals or None (for RPN)\n\n Returns:\n scores (ndarray): R x K array of object class scores (K includes\n background as object category 0)\n boxes (ndarray): R x (4*K) array of predicted bounding boxes\n \"\"\"\n blobs, im_scales = _get_blobs(im, boxes)\n\n # When mapping from image ROIs to feature map ROIs, there's some aliasing\n # (some distinct image ROIs get mapped to the same feature ROI).\n # Here, we identify duplicate feature ROIs, so we only compute features\n # on the unique subset.\n if cfg.DEDUP_BOXES > 0 and not cfg.TEST.HAS_RPN:\n v = np.array([1, 1e3, 1e6, 1e9, 1e12])\n hashes = np.round(blobs['rois'] * cfg.DEDUP_BOXES).dot(v)\n _, index, inv_index = np.unique(hashes, return_index=True,\n return_inverse=True)\n blobs['rois'] = blobs['rois'][index, :]\n boxes = boxes[index, :]\n\n if cfg.TEST.HAS_RPN:\n im_blob = blobs['data']\n blobs['im_info'] = np.array(\n [[im_blob.shape[2], im_blob.shape[3], im_scales[0]]],\n dtype=np.float32)\n\n # reshape network inputs\n net.blobs['data'].reshape(*(blobs['data'].shape))\n if cfg.TEST.HAS_RPN:\n net.blobs['im_info'].reshape(*(blobs['im_info'].shape))\n else:\n net.blobs['rois'].reshape(*(blobs['rois'].shape))\n\n # do forward\n forward_kwargs = {'data': blobs['data'].astype(np.float32, copy=False)}\n if cfg.TEST.HAS_RPN:\n forward_kwargs['im_info'] = blobs['im_info'].astype(np.float32, copy=False)\n else:\n forward_kwargs['rois'] = blobs['rois'].astype(np.float32, copy=False)\n blobs_out = net.forward(**forward_kwargs)\n\n if cfg.TEST.HAS_RPN:\n assert len(im_scales) == 1, \"Only single-image batch implemented\"\n rois = net.blobs['rois'].data.copy()\n # unscale back to raw image space\n boxes = rois[:, 1:5] / im_scales[0]\n\n if cfg.TEST.SVM:\n # use the raw scores before softmax under the assumption they\n # were trained as linear SVMs\n scores = net.blobs['cls_score'].data\n else:\n # use softmax estimated probabilities\n scores = blobs_out['cls_prob']\n\n if cfg.TEST.BBOX_REG:\n # Apply bounding-box regression deltas\n box_deltas = blobs_out['bbox_pred']\n pred_boxes = bbox_transform_inv(boxes, box_deltas)\n pred_boxes = clip_boxes(pred_boxes, im.shape)\n else:\n # Simply repeat the boxes, once for each class\n pred_boxes = np.tile(boxes, (1, scores.shape[1]))\n\n if cfg.DEDUP_BOXES > 0 and not cfg.TEST.HAS_RPN:\n # Map scores and predictions back to the original set of boxes\n scores = scores[inv_index, :]\n pred_boxes = pred_boxes[inv_index, :]\n\n return scores, pred_boxes\n\ndef vis_detections(im, class_name, dets, thresh=0.3):\n \"\"\"Visual debugging of detections.\"\"\"\n import matplotlib.pyplot as plt\n im = im[:, :, (2, 1, 0)]\n for i in xrange(np.minimum(10, dets.shape[0])):\n bbox = dets[i, :4]\n score = dets[i, -1]\n if score > thresh:\n plt.cla()\n plt.imshow(im)\n plt.gca().add_patch(\n plt.Rectangle((bbox[0], bbox[1]),\n bbox[2] - bbox[0],\n bbox[3] - bbox[1], fill=False,\n edgecolor='g', linewidth=3)\n )\n plt.title('{} {:.3f}'.format(class_name, score))\n plt.show()\n\ndef apply_nms(all_boxes, thresh):\n \"\"\"Apply non-maximum suppression to all predicted boxes output by the\n test_net method.\n \"\"\"\n num_classes = len(all_boxes)\n num_images = len(all_boxes[0])\n nms_boxes = [[[] for _ in xrange(num_images)]\n for _ in xrange(num_classes)]\n for cls_ind in xrange(num_classes):\n for im_ind in xrange(num_images):\n dets = all_boxes[cls_ind][im_ind]\n if dets == []:\n continue\n # CPU NMS is much faster than GPU NMS when the number of boxes\n # is relative small (e.g., < 10k)\n # TODO(rbg): autotune NMS dispatch\n keep = nms(dets, thresh, force_cpu=True)\n if len(keep) == 0:\n continue\n nms_boxes[cls_ind][im_ind] = dets[keep, :].copy()\n return nms_boxes\n\ndef test_net(net, imdb, max_per_image=100, thresh=0.05, vis=False):\n \"\"\"Test a Fast R-CNN network on an image database.\"\"\"\n num_images = len(imdb.image_index)\n # all detections are collected into:\n # all_boxes[cls][image] = N x 5 array of detections in\n # (x1, y1, x2, y2, score)\n all_boxes = [[[] for _ in xrange(num_images)]\n for _ in xrange(imdb.num_classes)]\n\n output_dir = get_output_dir(imdb, net)\n\n # timers\n _t = {'im_detect' : Timer(), 'misc' : Timer()}\n\n if not cfg.TEST.HAS_RPN:\n roidb = imdb.roidb\n\n for i in xrange(num_images):\n # filter out any ground truth boxes\n if cfg.TEST.HAS_RPN:\n box_proposals = None\n else:\n # The roidb may contain ground-truth rois (for example, if the roidb\n # comes from the training or val split). We only want to evaluate\n # detection on the *non*-ground-truth rois. We select those the rois\n # that have the gt_classes field set to 0, which means there's no\n # ground truth.\n box_proposals = roidb[i]['boxes'][roidb[i]['gt_classes'] == 0]\n\n im = cv2.imread(imdb.image_path_at(i))\n _t['im_detect'].tic()\n scores, boxes = im_detect(net, im, box_proposals)\n _t['im_detect'].toc()\n\n _t['misc'].tic()\n # skip j = 0, because it's the background class\n for j in xrange(1, imdb.num_classes):\n inds = np.where(scores[:, j] > thresh)[0]\n cls_scores = scores[inds, j]\n cls_boxes = boxes[inds, j*4:(j+1)*4]\n cls_dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \\\n .astype(np.float32, copy=False)\n keep = nms(cls_dets, cfg.TEST.NMS)\n cls_dets = cls_dets[keep, :]\n if vis:\n vis_detections(im, imdb.classes[j], cls_dets)\n all_boxes[j][i] = cls_dets\n\n # Limit to max_per_image detections *over all classes*\n if max_per_image > 0:\n image_scores = np.hstack([all_boxes[j][i][:, -1]\n for j in xrange(1, imdb.num_classes)])\n if len(image_scores) > max_per_image:\n image_thresh = np.sort(image_scores)[-max_per_image]\n for j in xrange(1, imdb.num_classes):\n keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0]\n all_boxes[j][i] = all_boxes[j][i][keep, :]\n _t['misc'].toc()\n\n print 'im_detect: {:d}/{:d} {:.3f}s {:.3f}s' \\\n .format(i + 1, num_images, _t['im_detect'].average_time,\n _t['misc'].average_time)\n\n det_file = os.path.join(output_dir, 'detections.pkl')\n with open(det_file, 'wb') as f:\n cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL)\n\n print 'Evaluating detections'\n imdb.evaluate_detections(all_boxes, output_dir)\n" }, { "path": "lib/fast_rcnn/train.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Train a Fast R-CNN network.\"\"\"\n\nimport caffe\nfrom fast_rcnn.config import cfg\nimport roi_data_layer.roidb as rdl_roidb\nfrom utils.timer import Timer\nimport numpy as np\nimport os\n\nfrom caffe.proto import caffe_pb2\nimport google.protobuf as pb2\n\nclass SolverWrapper(object):\n \"\"\"A simple wrapper around Caffe's solver.\n This wrapper gives us control over he snapshotting process, which we\n use to unnormalize the learned bounding-box regression weights.\n \"\"\"\n\n def __init__(self, solver_prototxt, roidb, output_dir,\n pretrained_model=None):\n \"\"\"Initialize the SolverWrapper.\"\"\"\n self.output_dir = output_dir\n\n if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and\n cfg.TRAIN.BBOX_NORMALIZE_TARGETS):\n # RPN can only use precomputed normalization because there are no\n # fixed statistics to compute a priori\n assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED\n\n if cfg.TRAIN.BBOX_REG:\n print 'Computing bounding-box regression targets...'\n self.bbox_means, self.bbox_stds = \\\n rdl_roidb.add_bbox_regression_targets(roidb)\n print 'done'\n\n self.solver = caffe.SGDSolver(solver_prototxt)\n if pretrained_model is not None:\n print ('Loading pretrained model '\n 'weights from {:s}').format(pretrained_model)\n self.solver.net.copy_from(pretrained_model)\n\n self.solver_param = caffe_pb2.SolverParameter()\n with open(solver_prototxt, 'rt') as f:\n pb2.text_format.Merge(f.read(), self.solver_param)\n\n self.solver.net.layers[0].set_roidb(roidb)\n\n def snapshot(self):\n \"\"\"Take a snapshot of the network after unnormalizing the learned\n bounding-box regression weights. This enables easy use at test-time.\n \"\"\"\n net = self.solver.net\n\n scale_bbox_params = (cfg.TRAIN.BBOX_REG and\n cfg.TRAIN.BBOX_NORMALIZE_TARGETS and\n net.params.has_key('bbox_pred'))\n\n if scale_bbox_params:\n # save original values\n orig_0 = net.params['bbox_pred'][0].data.copy()\n orig_1 = net.params['bbox_pred'][1].data.copy()\n\n # scale and shift with bbox reg unnormalization; then save snapshot\n net.params['bbox_pred'][0].data[...] = \\\n (net.params['bbox_pred'][0].data *\n self.bbox_stds[:, np.newaxis])\n net.params['bbox_pred'][1].data[...] = \\\n (net.params['bbox_pred'][1].data *\n self.bbox_stds + self.bbox_means)\n\n infix = ('_' + cfg.TRAIN.SNAPSHOT_INFIX\n if cfg.TRAIN.SNAPSHOT_INFIX != '' else '')\n filename = (self.solver_param.snapshot_prefix + infix +\n '_iter_{:d}'.format(self.solver.iter) + '.caffemodel')\n filename = os.path.join(self.output_dir, filename)\n\n net.save(str(filename))\n print 'Wrote snapshot to: {:s}'.format(filename)\n\n if scale_bbox_params:\n # restore net to original state\n net.params['bbox_pred'][0].data[...] = orig_0\n net.params['bbox_pred'][1].data[...] = orig_1\n return filename\n\n def train_model(self, max_iters):\n \"\"\"Network training loop.\"\"\"\n last_snapshot_iter = -1\n timer = Timer()\n model_paths = []\n while self.solver.iter < max_iters:\n # Make one SGD update\n timer.tic()\n self.solver.step(1)\n timer.toc()\n if self.solver.iter % (10 * self.solver_param.display) == 0:\n print 'speed: {:.3f}s / iter'.format(timer.average_time)\n\n if self.solver.iter % cfg.TRAIN.SNAPSHOT_ITERS == 0:\n last_snapshot_iter = self.solver.iter\n model_paths.append(self.snapshot())\n\n if last_snapshot_iter != self.solver.iter:\n model_paths.append(self.snapshot())\n return model_paths\n\ndef get_training_roidb(imdb):\n \"\"\"Returns a roidb (Region of Interest database) for use in training.\"\"\"\n if cfg.TRAIN.USE_FLIPPED:\n print 'Appending horizontally-flipped training examples...'\n imdb.append_flipped_images()\n print 'done'\n\n print 'Preparing training data...'\n rdl_roidb.prepare_roidb(imdb)\n print 'done'\n\n return imdb.roidb\n\ndef filter_roidb(roidb):\n \"\"\"Remove roidb entries that have no usable RoIs.\"\"\"\n\n def is_valid(entry):\n # Valid images have:\n # (1) At least one foreground RoI OR\n # (2) At least one background RoI\n overlaps = entry['max_overlaps']\n # find boxes with sufficient overlap\n fg_inds = np.where(overlaps >= cfg.TRAIN.FG_THRESH)[0]\n # Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)\n bg_inds = np.where((overlaps < cfg.TRAIN.BG_THRESH_HI) &\n (overlaps >= cfg.TRAIN.BG_THRESH_LO))[0]\n # image is only valid if such boxes exist\n valid = len(fg_inds) > 0 or len(bg_inds) > 0\n return valid\n\n num = len(roidb)\n filtered_roidb = [entry for entry in roidb if is_valid(entry)]\n num_after = len(filtered_roidb)\n print 'Filtered {} roidb entries: {} -> {}'.format(num - num_after,\n num, num_after)\n return filtered_roidb\n\ndef train_net(solver_prototxt, roidb, output_dir,\n pretrained_model=None, max_iters=40000):\n \"\"\"Train a Fast R-CNN network.\"\"\"\n\n roidb = filter_roidb(roidb)\n sw = SolverWrapper(solver_prototxt, roidb, output_dir,\n pretrained_model=pretrained_model)\n\n print 'Solving...'\n model_paths = sw.train_model(max_iters)\n print 'done solving'\n return model_paths\n" }, { "path": "lib/nms/.gitignore", "content": "*.c\n*.cpp\n*.so\n" }, { "path": "lib/nms/__init__.py", "content": "" }, { "path": "lib/nms/cpu_nms.pyx", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport numpy as np\ncimport numpy as np\n\ncdef inline np.float32_t max(np.float32_t a, np.float32_t b):\n return a if a >= b else b\n\ncdef inline np.float32_t min(np.float32_t a, np.float32_t b):\n return a if a <= b else b\n\ndef cpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):\n cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]\n cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]\n cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]\n cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]\n cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]\n\n cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n #cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1] #20160531, by MrX\n cdef np.ndarray[np.intp_t, ndim=1] order = scores.argsort()[::-1]\n\n cdef int ndets = dets.shape[0]\n cdef np.ndarray[np.int_t, ndim=1] suppressed = \\\n np.zeros((ndets), dtype=np.int)\n\n # nominal indices\n cdef int _i, _j\n # sorted indices\n cdef int i, j\n # temp variables for box i's (the box currently under consideration)\n cdef np.float32_t ix1, iy1, ix2, iy2, iarea\n # variables for computing overlap with box j (lower scoring box)\n cdef np.float32_t xx1, yy1, xx2, yy2\n cdef np.float32_t w, h\n cdef np.float32_t inter, ovr\n\n keep = []\n for _i in range(ndets):\n i = order[_i]\n if suppressed[i] == 1:\n continue\n keep.append(i)\n ix1 = x1[i]\n iy1 = y1[i]\n ix2 = x2[i]\n iy2 = y2[i]\n iarea = areas[i]\n for _j in range(_i + 1, ndets):\n j = order[_j]\n if suppressed[j] == 1:\n continue\n xx1 = max(ix1, x1[j])\n yy1 = max(iy1, y1[j])\n xx2 = min(ix2, x2[j])\n yy2 = min(iy2, y2[j])\n w = max(0.0, xx2 - xx1 + 1)\n h = max(0.0, yy2 - yy1 + 1)\n inter = w * h\n ovr = inter / (iarea + areas[j] - inter)\n if ovr >= thresh:\n suppressed[j] = 1\n\n return keep\n" }, { "path": "lib/nms/gpu_nms.cu", "content": "// ------------------------------------------------------------------\n// Faster R-CNN\n// Copyright (c) 2015 Microsoft\n// Licensed under The MIT License [see fast-rcnn/LICENSE for details]\n// Written by Shaoqing Ren\n// ------------------------------------------------------------------\n\n//#include \"gpu_nms.hpp\"\n#include \n#include \n\n\n#define CUDA_CHECK(condition) \\\n /* Code block avoids redefinition of cudaError_t error */ \\\n do { \\\n cudaError_t error = condition; \\\n if (error != cudaSuccess) { \\\n std::cout << cudaGetErrorString(error) << std::endl; \\\n } \\\n } while (0)\n\n#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0))\nint const threadsPerBlock = sizeof(unsigned long long) * 8;\n\n__device__ inline float devIoU(float const * const a, float const * const b) {\n float left = max(a[0], b[0]), right = min(a[2], b[2]);\n float top = max(a[1], b[1]), bottom = min(a[3], b[3]);\n float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f);\n float interS = width * height;\n float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1);\n float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1);\n return interS / (Sa + Sb - interS);\n}\n\n__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh,\n const float *dev_boxes, unsigned long long *dev_mask) {\n const int row_start = blockIdx.y;\n const int col_start = blockIdx.x;\n\n // if (row_start > col_start) return;\n\n const int row_size =\n min(n_boxes - row_start * threadsPerBlock, threadsPerBlock);\n const int col_size =\n min(n_boxes - col_start * threadsPerBlock, threadsPerBlock);\n\n __shared__ float block_boxes[threadsPerBlock * 5];\n if (threadIdx.x < col_size) {\n block_boxes[threadIdx.x * 5 + 0] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0];\n block_boxes[threadIdx.x * 5 + 1] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1];\n block_boxes[threadIdx.x * 5 + 2] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2];\n block_boxes[threadIdx.x * 5 + 3] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3];\n block_boxes[threadIdx.x * 5 + 4] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4];\n }\n __syncthreads();\n\n if (threadIdx.x < row_size) {\n const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x;\n const float *cur_box = dev_boxes + cur_box_idx * 5;\n int i = 0;\n unsigned long long t = 0;\n int start = 0;\n if (row_start == col_start) {\n start = threadIdx.x + 1;\n }\n for (i = start; i < col_size; i++) {\n if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) {\n t |= 1ULL << i;\n }\n }\n const int col_blocks = DIVUP(n_boxes, threadsPerBlock);\n dev_mask[cur_box_idx * col_blocks + col_start] = t;\n }\n}\n\nvoid _set_device(int device_id) {\n int current_device;\n CUDA_CHECK(cudaGetDevice(¤t_device));\n if (current_device == device_id) {\n return;\n }\n // The call to cudaSetDevice must come before any calls to Get, which\n // may perform initialization using the GPU.\n CUDA_CHECK(cudaSetDevice(device_id));\n}\n\nvoid _nms(long* keep_out, int* num_out, const float* boxes_host, int boxes_num,\n int boxes_dim, float nms_overlap_thresh, int device_id) {\n _set_device(device_id);\n\n float* boxes_dev = NULL;\n unsigned long long* mask_dev = NULL;\n\n const int col_blocks = DIVUP(boxes_num, threadsPerBlock);\n\n CUDA_CHECK(cudaMalloc(&boxes_dev,\n boxes_num * boxes_dim * sizeof(float)));\n CUDA_CHECK(cudaMemcpy(boxes_dev,\n boxes_host,\n boxes_num * boxes_dim * sizeof(float),\n cudaMemcpyHostToDevice));\n\n CUDA_CHECK(cudaMalloc(&mask_dev,\n boxes_num * col_blocks * sizeof(unsigned long long)));\n\n dim3 blocks(DIVUP(boxes_num, threadsPerBlock),\n DIVUP(boxes_num, threadsPerBlock));\n dim3 threads(threadsPerBlock);\n nms_kernel<<>>(boxes_num,\n nms_overlap_thresh,\n boxes_dev,\n mask_dev);\n\n std::vector mask_host(boxes_num * col_blocks);\n CUDA_CHECK(cudaMemcpy(&mask_host[0],\n mask_dev,\n sizeof(unsigned long long) * boxes_num * col_blocks,\n cudaMemcpyDeviceToHost));\n\n std::vector remv(col_blocks);\n memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks);\n\n int num_to_keep = 0;\n for (int i = 0; i < boxes_num; i++) {\n int nblock = i / threadsPerBlock;\n int inblock = i % threadsPerBlock;\n\n if (!(remv[nblock] & (1ULL << inblock))) {\n keep_out[num_to_keep++] = i;\n unsigned long long *p = &mask_host[0] + i * col_blocks;\n for (int j = nblock; j < col_blocks; j++) {\n remv[j] |= p[j];\n }\n }\n }\n *num_out = num_to_keep;\n\n CUDA_CHECK(cudaFree(boxes_dev));\n CUDA_CHECK(cudaFree(mask_dev));\n}\n\n\n\n\n\n\n\n\n\n\n/* Generated by Cython 0.24 */\n\n#define PY_SSIZE_T_CLEAN\n#include \"Python.h\"\n#ifndef Py_PYTHON_H\n #error Python headers needed to compile C extensions, please install development version of Python.\n#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)\n #error Cython requires Python 2.6+ or Python 3.2+.\n#else\n#define CYTHON_ABI \"0_24\"\n#include \n#ifndef offsetof\n #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )\n#endif\n#if !defined(WIN32) && !defined(MS_WINDOWS)\n #ifndef __stdcall\n #define __stdcall\n #endif\n #ifndef __cdecl\n #define __cdecl\n #endif\n #ifndef __fastcall\n #define __fastcall\n #endif\n#endif\n#ifndef DL_IMPORT\n #define DL_IMPORT(t) t\n#endif\n#ifndef DL_EXPORT\n #define DL_EXPORT(t) t\n#endif\n#ifndef PY_LONG_LONG\n #define PY_LONG_LONG LONG_LONG\n#endif\n#ifndef Py_HUGE_VAL\n #define Py_HUGE_VAL HUGE_VAL\n#endif\n#ifdef PYPY_VERSION\n #define CYTHON_COMPILING_IN_PYPY 1\n #define CYTHON_COMPILING_IN_CPYTHON 0\n#else\n #define CYTHON_COMPILING_IN_PYPY 0\n #define CYTHON_COMPILING_IN_CPYTHON 1\n#endif\n#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000\n #define CYTHON_USE_PYLONG_INTERNALS 1\n#endif\n#if CYTHON_USE_PYLONG_INTERNALS\n #include \"longintrepr.h\"\n #undef SHIFT\n #undef BASE\n #undef MASK\n#endif\n#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)\n #define Py_OptimizeFlag 0\n#endif\n#define __PYX_BUILD_PY_SSIZE_T \"n\"\n#define CYTHON_FORMAT_SSIZE_T \"z\"\n#if PY_MAJOR_VERSION < 3\n #define __Pyx_BUILTIN_MODULE_NAME \"__builtin__\"\n #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\\\n PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\n #define __Pyx_DefaultClassType PyClass_Type\n#else\n #define __Pyx_BUILTIN_MODULE_NAME \"builtins\"\n #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\\\n PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\n #define __Pyx_DefaultClassType PyType_Type\n#endif\n#ifndef Py_TPFLAGS_CHECKTYPES\n #define Py_TPFLAGS_CHECKTYPES 0\n#endif\n#ifndef Py_TPFLAGS_HAVE_INDEX\n #define Py_TPFLAGS_HAVE_INDEX 0\n#endif\n#ifndef Py_TPFLAGS_HAVE_NEWBUFFER\n #define Py_TPFLAGS_HAVE_NEWBUFFER 0\n#endif\n#ifndef Py_TPFLAGS_HAVE_FINALIZE\n #define Py_TPFLAGS_HAVE_FINALIZE 0\n#endif\n#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)\n #define CYTHON_PEP393_ENABLED 1\n #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\\\n 0 : _PyUnicode_Ready((PyObject *)(op)))\n #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)\n #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)\n #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)\n #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)\n #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)\n #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))\n#else\n #define CYTHON_PEP393_ENABLED 0\n #define __Pyx_PyUnicode_READY(op) (0)\n #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)\n #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))\n #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE))\n #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))\n #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))\n #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))\n#endif\n#if CYTHON_COMPILING_IN_PYPY\n #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)\n #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)\n#else\n #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)\n #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\\\n PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))\n#endif\n#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)\n #define PyUnicode_Contains(u, s) PySequence_Contains(u, s)\n#endif\n#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)\n #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, \"__format__\", \"O\", fmt)\n#endif\n#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)\n #define PyObject_Malloc(s) PyMem_Malloc(s)\n #define PyObject_Free(p) PyMem_Free(p)\n #define PyObject_Realloc(p) PyMem_Realloc(p)\n#endif\n#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))\n#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))\n#if PY_MAJOR_VERSION >= 3\n #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)\n#else\n #define __Pyx_PyString_Format(a, b) PyString_Format(a, b)\n#endif\n#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)\n #define PyObject_ASCII(o) PyObject_Repr(o)\n#endif\n#if PY_MAJOR_VERSION >= 3\n #define PyBaseString_Type PyUnicode_Type\n #define PyStringObject PyUnicodeObject\n #define PyString_Type PyUnicode_Type\n #define PyString_Check PyUnicode_Check\n #define PyString_CheckExact PyUnicode_CheckExact\n#endif\n#if PY_MAJOR_VERSION >= 3\n #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)\n #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)\n#else\n #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))\n #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))\n#endif\n#ifndef PySet_CheckExact\n #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type)\n#endif\n#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)\n#if PY_MAJOR_VERSION >= 3\n #define PyIntObject PyLongObject\n #define PyInt_Type PyLong_Type\n #define PyInt_Check(op) PyLong_Check(op)\n #define PyInt_CheckExact(op) PyLong_CheckExact(op)\n #define PyInt_FromString PyLong_FromString\n #define PyInt_FromUnicode PyLong_FromUnicode\n #define PyInt_FromLong PyLong_FromLong\n #define PyInt_FromSize_t PyLong_FromSize_t\n #define PyInt_FromSsize_t PyLong_FromSsize_t\n #define PyInt_AsLong PyLong_AsLong\n #define PyInt_AS_LONG PyLong_AS_LONG\n #define PyInt_AsSsize_t PyLong_AsSsize_t\n #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask\n #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask\n #define PyNumber_Int PyNumber_Long\n#endif\n#if PY_MAJOR_VERSION >= 3\n #define PyBoolObject PyLongObject\n#endif\n#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY\n #ifndef PyUnicode_InternFromString\n #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)\n #endif\n#endif\n#if PY_VERSION_HEX < 0x030200A4\n typedef long Py_hash_t;\n #define __Pyx_PyInt_FromHash_t PyInt_FromLong\n #define __Pyx_PyInt_AsHash_t PyInt_AsLong\n#else\n #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t\n #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t\n#endif\n#if PY_MAJOR_VERSION >= 3\n #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))\n#else\n #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)\n#endif\n#if PY_VERSION_HEX >= 0x030500B1\n#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods\n#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)\n#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3\ntypedef struct {\n unaryfunc am_await;\n unaryfunc am_aiter;\n unaryfunc am_anext;\n} __Pyx_PyAsyncMethodsStruct;\n#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))\n#else\n#define __Pyx_PyType_AsAsync(obj) NULL\n#endif\n#ifndef CYTHON_RESTRICT\n #if defined(__GNUC__)\n #define CYTHON_RESTRICT __restrict__\n #elif defined(_MSC_VER) && _MSC_VER >= 1400\n #define CYTHON_RESTRICT __restrict\n #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L\n #define CYTHON_RESTRICT restrict\n #else\n #define CYTHON_RESTRICT\n #endif\n#endif\n#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)\n\n#ifndef __cplusplus\n #error \"Cython files generated with the C++ option must be compiled with a C++ compiler.\"\n#endif\n#ifndef CYTHON_INLINE\n #define CYTHON_INLINE inline\n#endif\ntemplate\nvoid __Pyx_call_destructor(T& x) {\n x.~T();\n}\ntemplate\nclass __Pyx_FakeReference {\n public:\n __Pyx_FakeReference() : ptr(NULL) { }\n __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { }\n T *operator->() { return ptr; }\n operator T&() { return *ptr; }\n private:\n T *ptr;\n};\n\n#if defined(WIN32) || defined(MS_WINDOWS)\n #define _USE_MATH_DEFINES\n#endif\n#include \n#ifdef NAN\n#define __PYX_NAN() ((float) NAN)\n#else\nstatic CYTHON_INLINE float __PYX_NAN() {\n float value;\n memset(&value, 0xFF, sizeof(value));\n return value;\n}\n#endif\n\n\n#define __PYX_ERR(f_index, lineno, Ln_error) \\\n{ \\\n __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \\\n}\n\n#if PY_MAJOR_VERSION >= 3\n #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)\n #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)\n#else\n #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)\n #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)\n#endif\n\n#ifndef __PYX_EXTERN_C\n #ifdef __cplusplus\n #define __PYX_EXTERN_C extern \"C\"\n #else\n #define __PYX_EXTERN_C extern\n #endif\n#endif\n\n#define __PYX_HAVE__nms__gpu_nms\n#define __PYX_HAVE_API__nms__gpu_nms\n#include \"string.h\"\n#include \"stdio.h\"\n#include \"stdlib.h\"\n#include \"numpy/arrayobject.h\"\n#include \"numpy/ufuncobject.h\"\n#include \"gpu_nms.hpp\"\n#ifdef _OPENMP\n#include \n#endif /* _OPENMP */\n\n#ifdef PYREX_WITHOUT_ASSERTIONS\n#define CYTHON_WITHOUT_ASSERTIONS\n#endif\n\n#ifndef CYTHON_UNUSED\n# if defined(__GNUC__)\n# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))\n# define CYTHON_UNUSED __attribute__ ((__unused__))\n# else\n# define CYTHON_UNUSED\n# endif\n# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))\n# define CYTHON_UNUSED __attribute__ ((__unused__))\n# else\n# define CYTHON_UNUSED\n# endif\n#endif\n#ifndef CYTHON_NCP_UNUSED\n# if CYTHON_COMPILING_IN_CPYTHON\n# define CYTHON_NCP_UNUSED\n# else\n# define CYTHON_NCP_UNUSED CYTHON_UNUSED\n# endif\n#endif\ntypedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;\n const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;\n\n#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0\n#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0\n#define __PYX_DEFAULT_STRING_ENCODING \"\"\n#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString\n#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize\n#define __Pyx_uchar_cast(c) ((unsigned char)c)\n#define __Pyx_long_cast(x) ((long)x)\n#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\\\n (sizeof(type) < sizeof(Py_ssize_t)) ||\\\n (sizeof(type) > sizeof(Py_ssize_t) &&\\\n likely(v < (type)PY_SSIZE_T_MAX ||\\\n v == (type)PY_SSIZE_T_MAX) &&\\\n (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\\\n v == (type)PY_SSIZE_T_MIN))) ||\\\n (sizeof(type) == sizeof(Py_ssize_t) &&\\\n (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\\\n v == (type)PY_SSIZE_T_MAX))) )\n#if defined (__cplusplus) && __cplusplus >= 201103L\n #include \n #define __Pyx_sst_abs(value) std::abs(value)\n#elif SIZEOF_INT >= SIZEOF_SIZE_T\n #define __Pyx_sst_abs(value) abs(value)\n#elif SIZEOF_LONG >= SIZEOF_SIZE_T\n #define __Pyx_sst_abs(value) labs(value)\n#elif defined (_MSC_VER) && defined (_M_X64)\n #define __Pyx_sst_abs(value) _abs64(value)\n#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L\n #define __Pyx_sst_abs(value) llabs(value)\n#elif defined (__GNUC__)\n #define __Pyx_sst_abs(value) __builtin_llabs(value)\n#else\n #define __Pyx_sst_abs(value) ((value<0) ? -value : value)\n#endif\nstatic CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);\nstatic CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);\n#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))\n#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)\n#define __Pyx_PyBytes_FromString PyBytes_FromString\n#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize\nstatic CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);\n#if PY_MAJOR_VERSION < 3\n #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString\n #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize\n#else\n #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString\n #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize\n#endif\n#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s))\n#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s))\n#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)\n#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s)\n#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s)\n#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s)\n#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)\n#if PY_MAJOR_VERSION < 3\nstatic CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)\n{\n const Py_UNICODE *u_end = u;\n while (*u_end++) ;\n return (size_t)(u_end - u - 1);\n}\n#else\n#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen\n#endif\n#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))\n#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode\n#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode\n#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)\n#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)\n#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))\nstatic CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);\nstatic CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);\nstatic CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);\nstatic CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);\n#if CYTHON_COMPILING_IN_CPYTHON\n#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))\n#else\n#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)\n#endif\n#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))\n#if PY_MAJOR_VERSION >= 3\n#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))\n#else\n#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))\n#endif\n#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))\n#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII\nstatic int __Pyx_sys_getdefaultencoding_not_ascii;\nstatic int __Pyx_init_sys_getdefaultencoding_params(void) {\n PyObject* sys;\n PyObject* default_encoding = NULL;\n PyObject* ascii_chars_u = NULL;\n PyObject* ascii_chars_b = NULL;\n const char* default_encoding_c;\n sys = PyImport_ImportModule(\"sys\");\n if (!sys) goto bad;\n default_encoding = PyObject_CallMethod(sys, (char*) \"getdefaultencoding\", NULL);\n Py_DECREF(sys);\n if (!default_encoding) goto bad;\n default_encoding_c = PyBytes_AsString(default_encoding);\n if (!default_encoding_c) goto bad;\n if (strcmp(default_encoding_c, \"ascii\") == 0) {\n __Pyx_sys_getdefaultencoding_not_ascii = 0;\n } else {\n char ascii_chars[128];\n int c;\n for (c = 0; c < 128; c++) {\n ascii_chars[c] = c;\n }\n __Pyx_sys_getdefaultencoding_not_ascii = 1;\n ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);\n if (!ascii_chars_u) goto bad;\n ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);\n if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {\n PyErr_Format(\n PyExc_ValueError,\n \"This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.\",\n default_encoding_c);\n goto bad;\n }\n Py_DECREF(ascii_chars_u);\n Py_DECREF(ascii_chars_b);\n }\n Py_DECREF(default_encoding);\n return 0;\nbad:\n Py_XDECREF(default_encoding);\n Py_XDECREF(ascii_chars_u);\n Py_XDECREF(ascii_chars_b);\n return -1;\n}\n#endif\n#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3\n#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)\n#else\n#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)\n#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT\nstatic char* __PYX_DEFAULT_STRING_ENCODING;\nstatic int __Pyx_init_sys_getdefaultencoding_params(void) {\n PyObject* sys;\n PyObject* default_encoding = NULL;\n char* default_encoding_c;\n sys = PyImport_ImportModule(\"sys\");\n if (!sys) goto bad;\n default_encoding = PyObject_CallMethod(sys, (char*) (const char*) \"getdefaultencoding\", NULL);\n Py_DECREF(sys);\n if (!default_encoding) goto bad;\n default_encoding_c = PyBytes_AsString(default_encoding);\n if (!default_encoding_c) goto bad;\n __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));\n if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;\n strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);\n Py_DECREF(default_encoding);\n return 0;\nbad:\n Py_XDECREF(default_encoding);\n return -1;\n}\n#endif\n#endif\n\n\n/* Test for GCC > 2.95 */\n#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))\n #define likely(x) __builtin_expect(!!(x), 1)\n #define unlikely(x) __builtin_expect(!!(x), 0)\n#else /* !__GNUC__ or GCC < 2.95 */\n #define likely(x) (x)\n #define unlikely(x) (x)\n#endif /* __GNUC__ */\n\nstatic PyObject *__pyx_m;\nstatic PyObject *__pyx_d;\nstatic PyObject *__pyx_b;\nstatic PyObject *__pyx_empty_tuple;\nstatic PyObject *__pyx_empty_bytes;\nstatic PyObject *__pyx_empty_unicode;\nstatic int __pyx_lineno;\nstatic int __pyx_clineno = 0;\nstatic const char * __pyx_cfilenm= __FILE__;\nstatic const char *__pyx_filename;\n\n/* None.proto */\n#if !defined(CYTHON_CCOMPLEX)\n #if defined(__cplusplus)\n #define CYTHON_CCOMPLEX 1\n #elif defined(_Complex_I)\n #define CYTHON_CCOMPLEX 1\n #else\n #define CYTHON_CCOMPLEX 0\n #endif\n#endif\n#if CYTHON_CCOMPLEX\n #ifdef __cplusplus\n #include \n #else\n #include \n #endif\n#endif\n#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)\n #undef _Complex_I\n #define _Complex_I 1.0fj\n#endif\n\n\nstatic const char *__pyx_f[] = {\n \"nms\\\\gpu_nms.pyx\",\n \"__init__.pxd\",\n \"type.pxd\",\n};\n/* BufferFormatStructs.proto */\n#define IS_UNSIGNED(type) (((type) -1) > 0)\nstruct __Pyx_StructField_;\n#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)\ntypedef struct {\n const char* name;\n struct __Pyx_StructField_* fields;\n size_t size;\n size_t arraysize[8];\n int ndim;\n char typegroup;\n char is_unsigned;\n int flags;\n} __Pyx_TypeInfo;\ntypedef struct __Pyx_StructField_ {\n __Pyx_TypeInfo* type;\n const char* name;\n size_t offset;\n} __Pyx_StructField;\ntypedef struct {\n __Pyx_StructField* field;\n size_t parent_offset;\n} __Pyx_BufFmt_StackElem;\ntypedef struct {\n __Pyx_StructField root;\n __Pyx_BufFmt_StackElem* head;\n size_t fmt_offset;\n size_t new_count, enc_count;\n size_t struct_alignment;\n int is_complex;\n char enc_type;\n char new_packmode;\n char enc_packmode;\n char is_valid_array;\n} __Pyx_BufFmt_Context;\n\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":725\n * # in Cython to enable them only on the right systems.\n * \n * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<<\n * ctypedef npy_int16 int16_t\n * ctypedef npy_int32 int32_t\n */\ntypedef npy_int8 __pyx_t_5numpy_int8_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":726\n * \n * ctypedef npy_int8 int8_t\n * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<<\n * ctypedef npy_int32 int32_t\n * ctypedef npy_int64 int64_t\n */\ntypedef npy_int16 __pyx_t_5numpy_int16_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":727\n * ctypedef npy_int8 int8_t\n * ctypedef npy_int16 int16_t\n * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<<\n * ctypedef npy_int64 int64_t\n * #ctypedef npy_int96 int96_t\n */\ntypedef npy_int32 __pyx_t_5numpy_int32_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":728\n * ctypedef npy_int16 int16_t\n * ctypedef npy_int32 int32_t\n * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<<\n * #ctypedef npy_int96 int96_t\n * #ctypedef npy_int128 int128_t\n */\ntypedef npy_int64 __pyx_t_5numpy_int64_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":732\n * #ctypedef npy_int128 int128_t\n * \n * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<<\n * ctypedef npy_uint16 uint16_t\n * ctypedef npy_uint32 uint32_t\n */\ntypedef npy_uint8 __pyx_t_5numpy_uint8_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":733\n * \n * ctypedef npy_uint8 uint8_t\n * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<<\n * ctypedef npy_uint32 uint32_t\n * ctypedef npy_uint64 uint64_t\n */\ntypedef npy_uint16 __pyx_t_5numpy_uint16_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":734\n * ctypedef npy_uint8 uint8_t\n * ctypedef npy_uint16 uint16_t\n * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<<\n * ctypedef npy_uint64 uint64_t\n * #ctypedef npy_uint96 uint96_t\n */\ntypedef npy_uint32 __pyx_t_5numpy_uint32_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":735\n * ctypedef npy_uint16 uint16_t\n * ctypedef npy_uint32 uint32_t\n * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<<\n * #ctypedef npy_uint96 uint96_t\n * #ctypedef npy_uint128 uint128_t\n */\ntypedef npy_uint64 __pyx_t_5numpy_uint64_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":739\n * #ctypedef npy_uint128 uint128_t\n * \n * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<<\n * ctypedef npy_float64 float64_t\n * #ctypedef npy_float80 float80_t\n */\ntypedef npy_float32 __pyx_t_5numpy_float32_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":740\n * \n * ctypedef npy_float32 float32_t\n * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<<\n * #ctypedef npy_float80 float80_t\n * #ctypedef npy_float128 float128_t\n */\ntypedef npy_float64 __pyx_t_5numpy_float64_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":749\n * # The int types are mapped a bit surprising --\n * # numpy.int corresponds to 'l' and numpy.long to 'q'\n * ctypedef npy_long int_t # <<<<<<<<<<<<<<\n * ctypedef npy_longlong long_t\n * ctypedef npy_longlong longlong_t\n */\ntypedef npy_long __pyx_t_5numpy_int_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":750\n * # numpy.int corresponds to 'l' and numpy.long to 'q'\n * ctypedef npy_long int_t\n * ctypedef npy_longlong long_t # <<<<<<<<<<<<<<\n * ctypedef npy_longlong longlong_t\n * \n */\ntypedef npy_longlong __pyx_t_5numpy_long_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":751\n * ctypedef npy_long int_t\n * ctypedef npy_longlong long_t\n * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<<\n * \n * ctypedef npy_ulong uint_t\n */\ntypedef npy_longlong __pyx_t_5numpy_longlong_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":753\n * ctypedef npy_longlong longlong_t\n * \n * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<<\n * ctypedef npy_ulonglong ulong_t\n * ctypedef npy_ulonglong ulonglong_t\n */\ntypedef npy_ulong __pyx_t_5numpy_uint_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":754\n * \n * ctypedef npy_ulong uint_t\n * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<<\n * ctypedef npy_ulonglong ulonglong_t\n * \n */\ntypedef npy_ulonglong __pyx_t_5numpy_ulong_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":755\n * ctypedef npy_ulong uint_t\n * ctypedef npy_ulonglong ulong_t\n * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<<\n * \n * ctypedef npy_intp intp_t\n */\ntypedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":757\n * ctypedef npy_ulonglong ulonglong_t\n * \n * ctypedef npy_intp intp_t # <<<<<<<<<<<<<<\n * ctypedef npy_uintp uintp_t\n * \n */\ntypedef npy_intp __pyx_t_5numpy_intp_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":758\n * \n * ctypedef npy_intp intp_t\n * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<<\n * \n * ctypedef npy_double float_t\n */\ntypedef npy_uintp __pyx_t_5numpy_uintp_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":760\n * ctypedef npy_uintp uintp_t\n * \n * ctypedef npy_double float_t # <<<<<<<<<<<<<<\n * ctypedef npy_double double_t\n * ctypedef npy_longdouble longdouble_t\n */\ntypedef npy_double __pyx_t_5numpy_float_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":761\n * \n * ctypedef npy_double float_t\n * ctypedef npy_double double_t # <<<<<<<<<<<<<<\n * ctypedef npy_longdouble longdouble_t\n * \n */\ntypedef npy_double __pyx_t_5numpy_double_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":762\n * ctypedef npy_double float_t\n * ctypedef npy_double double_t\n * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<<\n * \n * ctypedef npy_cfloat cfloat_t\n */\ntypedef npy_longdouble __pyx_t_5numpy_longdouble_t;\n/* None.proto */\n#if CYTHON_CCOMPLEX\n #ifdef __cplusplus\n typedef ::std::complex< float > __pyx_t_float_complex;\n #else\n typedef float _Complex __pyx_t_float_complex;\n #endif\n#else\n typedef struct { float real, imag; } __pyx_t_float_complex;\n#endif\n\n/* None.proto */\n#if CYTHON_CCOMPLEX\n #ifdef __cplusplus\n typedef ::std::complex< double > __pyx_t_double_complex;\n #else\n typedef double _Complex __pyx_t_double_complex;\n #endif\n#else\n typedef struct { double real, imag; } __pyx_t_double_complex;\n#endif\n\n\n/*--- Type declarations ---*/\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":764\n * ctypedef npy_longdouble longdouble_t\n * \n * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<<\n * ctypedef npy_cdouble cdouble_t\n * ctypedef npy_clongdouble clongdouble_t\n */\ntypedef npy_cfloat __pyx_t_5numpy_cfloat_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":765\n * \n * ctypedef npy_cfloat cfloat_t\n * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<<\n * ctypedef npy_clongdouble clongdouble_t\n * \n */\ntypedef npy_cdouble __pyx_t_5numpy_cdouble_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":766\n * ctypedef npy_cfloat cfloat_t\n * ctypedef npy_cdouble cdouble_t\n * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<<\n * \n * ctypedef npy_cdouble complex_t\n */\ntypedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":768\n * ctypedef npy_clongdouble clongdouble_t\n * \n * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<<\n * \n * cdef inline object PyArray_MultiIterNew1(a):\n */\ntypedef npy_cdouble __pyx_t_5numpy_complex_t;\n\n/* --- Runtime support code (head) --- */\n/* Refnanny.proto */\n#ifndef CYTHON_REFNANNY\n #define CYTHON_REFNANNY 0\n#endif\n#if CYTHON_REFNANNY\n typedef struct {\n void (*INCREF)(void*, PyObject*, int);\n void (*DECREF)(void*, PyObject*, int);\n void (*GOTREF)(void*, PyObject*, int);\n void (*GIVEREF)(void*, PyObject*, int);\n void* (*SetupContext)(const char*, int, const char*);\n void (*FinishContext)(void**);\n } __Pyx_RefNannyAPIStruct;\n static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;\n static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);\n #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;\n#ifdef WITH_THREAD\n #define __Pyx_RefNannySetupContext(name, acquire_gil)\\\n if (acquire_gil) {\\\n PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\\\n __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\\\n PyGILState_Release(__pyx_gilstate_save);\\\n } else {\\\n __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\\\n }\n#else\n #define __Pyx_RefNannySetupContext(name, acquire_gil)\\\n __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)\n#endif\n #define __Pyx_RefNannyFinishContext()\\\n __Pyx_RefNanny->FinishContext(&__pyx_refnanny)\n #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)\n #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)\n #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)\n #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)\n #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)\n #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)\n #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)\n #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)\n#else\n #define __Pyx_RefNannyDeclarations\n #define __Pyx_RefNannySetupContext(name, acquire_gil)\n #define __Pyx_RefNannyFinishContext()\n #define __Pyx_INCREF(r) Py_INCREF(r)\n #define __Pyx_DECREF(r) Py_DECREF(r)\n #define __Pyx_GOTREF(r)\n #define __Pyx_GIVEREF(r)\n #define __Pyx_XINCREF(r) Py_XINCREF(r)\n #define __Pyx_XDECREF(r) Py_XDECREF(r)\n #define __Pyx_XGOTREF(r)\n #define __Pyx_XGIVEREF(r)\n#endif\n#define __Pyx_XDECREF_SET(r, v) do {\\\n PyObject *tmp = (PyObject *) r;\\\n r = v; __Pyx_XDECREF(tmp);\\\n } while (0)\n#define __Pyx_DECREF_SET(r, v) do {\\\n PyObject *tmp = (PyObject *) r;\\\n r = v; __Pyx_DECREF(tmp);\\\n } while (0)\n#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)\n#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)\n\n/* RaiseArgTupleInvalid.proto */\nstatic void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,\n Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);\n\n/* RaiseDoubleKeywords.proto */\nstatic void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);\n\n/* ParseKeywords.proto */\nstatic int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\\\n PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\\\n const char* function_name);\n\n/* ArgTypeTest.proto */\nstatic CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,\n const char *name, int exact);\n\n/* BufferFormatCheck.proto */\nstatic CYTHON_INLINE int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj,\n __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);\nstatic CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);\nstatic const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);\nstatic void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,\n __Pyx_BufFmt_StackElem* stack,\n __Pyx_TypeInfo* type); // PROTO\n\n/* PyObjectGetAttrStr.proto */\n#if CYTHON_COMPILING_IN_CPYTHON\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {\n PyTypeObject* tp = Py_TYPE(obj);\n if (likely(tp->tp_getattro))\n return tp->tp_getattro(obj, attr_name);\n#if PY_MAJOR_VERSION < 3\n if (likely(tp->tp_getattr))\n return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));\n#endif\n return PyObject_GetAttr(obj, attr_name);\n}\n#else\n#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)\n#endif\n\n/* GetBuiltinName.proto */\nstatic PyObject *__Pyx_GetBuiltinName(PyObject *name);\n\n/* GetModuleGlobalName.proto */\nstatic CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);\n\n/* PyObjectCall.proto */\n#if CYTHON_COMPILING_IN_CPYTHON\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);\n#else\n#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)\n#endif\n\n/* ExtTypeTest.proto */\nstatic CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);\n\n/* PyObjectCallMethO.proto */\n#if CYTHON_COMPILING_IN_CPYTHON\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);\n#endif\n\n/* PyObjectCallOneArg.proto */\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);\n\n/* PyObjectCallNoArg.proto */\n#if CYTHON_COMPILING_IN_CPYTHON\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);\n#else\n#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)\n#endif\n\n/* BufferIndexError.proto */\nstatic void __Pyx_RaiseBufferIndexError(int axis);\n\n#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)\n#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1)\n/* SliceObject.proto */\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(\n PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,\n PyObject** py_start, PyObject** py_stop, PyObject** py_slice,\n int has_cstart, int has_cstop, int wraparound);\n\n/* BufferFallbackError.proto */\nstatic void __Pyx_RaiseBufferFallbackError(void);\n\n/* PyThreadStateGet.proto */\n#if CYTHON_COMPILING_IN_CPYTHON\n#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;\n#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET();\n#else\n#define __Pyx_PyThreadState_declare\n#define __Pyx_PyThreadState_assign\n#endif\n\n/* PyErrFetchRestore.proto */\n#if CYTHON_COMPILING_IN_CPYTHON\n#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)\n#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)\n#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)\n#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)\nstatic CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);\nstatic CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);\n#else\n#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)\n#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)\n#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)\n#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)\n#endif\n\n/* RaiseException.proto */\nstatic void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);\n\n/* DictGetItem.proto */\n#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY\nstatic PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {\n PyObject *value;\n value = PyDict_GetItemWithError(d, key);\n if (unlikely(!value)) {\n if (!PyErr_Occurred()) {\n PyObject* args = PyTuple_Pack(1, key);\n if (likely(args))\n PyErr_SetObject(PyExc_KeyError, args);\n Py_XDECREF(args);\n }\n return NULL;\n }\n Py_INCREF(value);\n return value;\n}\n#else\n #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)\n#endif\n\n/* RaiseTooManyValuesToUnpack.proto */\nstatic CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);\n\n/* RaiseNeedMoreValuesToUnpack.proto */\nstatic CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);\n\n/* RaiseNoneIterError.proto */\nstatic CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);\n\n/* Import.proto */\nstatic PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);\n\n/* CodeObjectCache.proto */\ntypedef struct {\n PyCodeObject* code_object;\n int code_line;\n} __Pyx_CodeObjectCacheEntry;\nstruct __Pyx_CodeObjectCache {\n int count;\n int max_count;\n __Pyx_CodeObjectCacheEntry* entries;\n};\nstatic struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};\nstatic int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);\nstatic PyCodeObject *__pyx_find_code_object(int code_line);\nstatic void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);\n\n/* AddTraceback.proto */\nstatic void __Pyx_AddTraceback(const char *funcname, int c_line,\n int py_line, const char *filename);\n\n/* BufferStructDeclare.proto */\ntypedef struct {\n Py_ssize_t shape, strides, suboffsets;\n} __Pyx_Buf_DimInfo;\ntypedef struct {\n size_t refcount;\n Py_buffer pybuffer;\n} __Pyx_Buffer;\ntypedef struct {\n __Pyx_Buffer *rcbuffer;\n char *data;\n __Pyx_Buf_DimInfo diminfo[8];\n} __Pyx_LocalBuf_ND;\n\n#if PY_MAJOR_VERSION < 3\n static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);\n static void __Pyx_ReleaseBuffer(Py_buffer *view);\n#else\n #define __Pyx_GetBuffer PyObject_GetBuffer\n #define __Pyx_ReleaseBuffer PyBuffer_Release\n#endif\n\n\n/* None.proto */\nstatic Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0};\nstatic Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1};\n\n/* CIntToPy.proto */\nstatic CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);\n\n/* None.proto */\n#if CYTHON_CCOMPLEX\n #ifdef __cplusplus\n #define __Pyx_CREAL(z) ((z).real())\n #define __Pyx_CIMAG(z) ((z).imag())\n #else\n #define __Pyx_CREAL(z) (__real__(z))\n #define __Pyx_CIMAG(z) (__imag__(z))\n #endif\n#else\n #define __Pyx_CREAL(z) ((z).real)\n #define __Pyx_CIMAG(z) ((z).imag)\n#endif\n#if defined(__cplusplus) && CYTHON_CCOMPLEX && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)\n #define __Pyx_SET_CREAL(z,x) ((z).real(x))\n #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))\n#else\n #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)\n #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)\n#endif\n\n/* None.proto */\nstatic CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);\n\n/* None.proto */\n#if CYTHON_CCOMPLEX\n #define __Pyx_c_eqf(a, b) ((a)==(b))\n #define __Pyx_c_sumf(a, b) ((a)+(b))\n #define __Pyx_c_difff(a, b) ((a)-(b))\n #define __Pyx_c_prodf(a, b) ((a)*(b))\n #define __Pyx_c_quotf(a, b) ((a)/(b))\n #define __Pyx_c_negf(a) (-(a))\n #ifdef __cplusplus\n #define __Pyx_c_is_zerof(z) ((z)==(float)0)\n #define __Pyx_c_conjf(z) (::std::conj(z))\n #if 1\n #define __Pyx_c_absf(z) (::std::abs(z))\n #define __Pyx_c_powf(a, b) (::std::pow(a, b))\n #endif\n #else\n #define __Pyx_c_is_zerof(z) ((z)==0)\n #define __Pyx_c_conjf(z) (conjf(z))\n #if 1\n #define __Pyx_c_absf(z) (cabsf(z))\n #define __Pyx_c_powf(a, b) (cpowf(a, b))\n #endif\n #endif\n#else\n static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex);\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex);\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex);\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex);\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex);\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex);\n static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex);\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex);\n #if 1\n static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex);\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex);\n #endif\n#endif\n\n/* None.proto */\nstatic CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);\n\n/* None.proto */\n#if CYTHON_CCOMPLEX\n #define __Pyx_c_eq(a, b) ((a)==(b))\n #define __Pyx_c_sum(a, b) ((a)+(b))\n #define __Pyx_c_diff(a, b) ((a)-(b))\n #define __Pyx_c_prod(a, b) ((a)*(b))\n #define __Pyx_c_quot(a, b) ((a)/(b))\n #define __Pyx_c_neg(a) (-(a))\n #ifdef __cplusplus\n #define __Pyx_c_is_zero(z) ((z)==(double)0)\n #define __Pyx_c_conj(z) (::std::conj(z))\n #if 1\n #define __Pyx_c_abs(z) (::std::abs(z))\n #define __Pyx_c_pow(a, b) (::std::pow(a, b))\n #endif\n #else\n #define __Pyx_c_is_zero(z) ((z)==0)\n #define __Pyx_c_conj(z) (conj(z))\n #if 1\n #define __Pyx_c_abs(z) (cabs(z))\n #define __Pyx_c_pow(a, b) (cpow(a, b))\n #endif\n #endif\n#else\n static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex);\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex);\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex);\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex);\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex);\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex);\n static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex);\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex);\n #if 1\n static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex);\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex);\n #endif\n#endif\n\n/* CIntToPy.proto */\nstatic CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);\n\n/* CIntFromPy.proto */\nstatic CYTHON_INLINE npy_int32 __Pyx_PyInt_As_npy_int32(PyObject *);\n\n/* CIntFromPy.proto */\nstatic CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);\n\n/* CIntToPy.proto */\nstatic CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);\n\n/* CIntFromPy.proto */\nstatic CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);\n\n/* CheckBinaryVersion.proto */\nstatic int __Pyx_check_binary_version(void);\n\n/* PyIdentifierFromString.proto */\n#if !defined(__Pyx_PyIdentifier_FromString)\n#if PY_MAJOR_VERSION < 3\n #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)\n#else\n #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)\n#endif\n#endif\n\n/* ModuleImport.proto */\nstatic PyObject *__Pyx_ImportModule(const char *name);\n\n/* TypeImport.proto */\nstatic PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);\n\n/* InitStrings.proto */\nstatic int __Pyx_InitStrings(__Pyx_StringTabEntry *t);\n\n\n/* Module declarations from 'cpython.buffer' */\n\n/* Module declarations from 'libc.string' */\n\n/* Module declarations from 'libc.stdio' */\n\n/* Module declarations from '__builtin__' */\n\n/* Module declarations from 'cpython.type' */\nstatic PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;\n\n/* Module declarations from 'cpython' */\n\n/* Module declarations from 'cpython.object' */\n\n/* Module declarations from 'cpython.ref' */\n\n/* Module declarations from 'libc.stdlib' */\n\n/* Module declarations from 'numpy' */\n\n/* Module declarations from 'numpy' */\nstatic PyTypeObject *__pyx_ptype_5numpy_dtype = 0;\nstatic PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;\nstatic PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;\nstatic PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;\nstatic PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;\nstatic CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/\n\n/* Module declarations from 'nms.gpu_nms' */\nstatic __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t = { \"float32_t\", NULL, sizeof(__pyx_t_5numpy_float32_t), { 0 }, 0, 'R', 0, 0 };\nstatic __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t = { \"int32_t\", NULL, sizeof(__pyx_t_5numpy_int32_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int32_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int32_t), 0 };\nstatic __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_intp_t = { \"intp_t\", NULL, sizeof(__pyx_t_5numpy_intp_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_intp_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_intp_t), 0 };\n#define __Pyx_MODULE_NAME \"nms.gpu_nms\"\nint __pyx_module_is_main_nms__gpu_nms = 0;\n\n/* Implementation of 'nms.gpu_nms' */\nstatic PyObject *__pyx_builtin_ValueError;\nstatic PyObject *__pyx_builtin_range;\nstatic PyObject *__pyx_builtin_RuntimeError;\nstatic const char __pyx_k_np[] = \"np\";\nstatic const char __pyx_k_dets[] = \"dets\";\nstatic const char __pyx_k_keep[] = \"keep\";\nstatic const char __pyx_k_main[] = \"__main__\";\nstatic const char __pyx_k_test[] = \"__test__\";\nstatic const char __pyx_k_dtype[] = \"dtype\";\nstatic const char __pyx_k_int32[] = \"int32\";\nstatic const char __pyx_k_numpy[] = \"numpy\";\nstatic const char __pyx_k_order[] = \"order\";\nstatic const char __pyx_k_range[] = \"range\";\nstatic const char __pyx_k_zeros[] = \"zeros\";\nstatic const char __pyx_k_import[] = \"__import__\";\nstatic const char __pyx_k_scores[] = \"scores\";\nstatic const char __pyx_k_thresh[] = \"thresh\";\nstatic const char __pyx_k_argsort[] = \"argsort\";\nstatic const char __pyx_k_gpu_nms[] = \"gpu_nms\";\nstatic const char __pyx_k_num_out[] = \"num_out\";\nstatic const char __pyx_k_boxes_dim[] = \"boxes_dim\";\nstatic const char __pyx_k_boxes_num[] = \"boxes_num\";\nstatic const char __pyx_k_device_id[] = \"device_id\";\nstatic const char __pyx_k_ValueError[] = \"ValueError\";\nstatic const char __pyx_k_nms_gpu_nms[] = \"nms.gpu_nms\";\nstatic const char __pyx_k_sorted_dets[] = \"sorted_dets\";\nstatic const char __pyx_k_RuntimeError[] = \"RuntimeError\";\nstatic const char __pyx_k_ndarray_is_not_C_contiguous[] = \"ndarray is not C contiguous\";\nstatic const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = \"unknown dtype code in numpy.pxd (%d)\";\nstatic const char __pyx_k_D_v_zix_caffe_caffe_win_20160523[] = \"D:\\\\v-zix\\\\caffe\\\\caffe-win-20160523\\\\models\\\\py-faster-rcnn-windows\\\\lib\\\\nms\\\\gpu_nms.pyx\";\nstatic const char __pyx_k_Format_string_allocated_too_shor[] = \"Format string allocated too short, see comment in numpy.pxd\";\nstatic const char __pyx_k_Non_native_byte_order_not_suppor[] = \"Non-native byte order not supported\";\nstatic const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = \"ndarray is not Fortran contiguous\";\nstatic const char __pyx_k_Format_string_allocated_too_shor_2[] = \"Format string allocated too short.\";\nstatic PyObject *__pyx_kp_s_D_v_zix_caffe_caffe_win_20160523;\nstatic PyObject *__pyx_kp_u_Format_string_allocated_too_shor;\nstatic PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;\nstatic PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;\nstatic PyObject *__pyx_n_s_RuntimeError;\nstatic PyObject *__pyx_n_s_ValueError;\nstatic PyObject *__pyx_n_s_argsort;\nstatic PyObject *__pyx_n_s_boxes_dim;\nstatic PyObject *__pyx_n_s_boxes_num;\nstatic PyObject *__pyx_n_s_dets;\nstatic PyObject *__pyx_n_s_device_id;\nstatic PyObject *__pyx_n_s_dtype;\nstatic PyObject *__pyx_n_s_gpu_nms;\nstatic PyObject *__pyx_n_s_import;\nstatic PyObject *__pyx_n_s_int32;\nstatic PyObject *__pyx_n_s_keep;\nstatic PyObject *__pyx_n_s_main;\nstatic PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;\nstatic PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;\nstatic PyObject *__pyx_n_s_nms_gpu_nms;\nstatic PyObject *__pyx_n_s_np;\nstatic PyObject *__pyx_n_s_num_out;\nstatic PyObject *__pyx_n_s_numpy;\nstatic PyObject *__pyx_n_s_order;\nstatic PyObject *__pyx_n_s_range;\nstatic PyObject *__pyx_n_s_scores;\nstatic PyObject *__pyx_n_s_sorted_dets;\nstatic PyObject *__pyx_n_s_test;\nstatic PyObject *__pyx_n_s_thresh;\nstatic PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;\nstatic PyObject *__pyx_n_s_zeros;\nstatic PyObject *__pyx_pf_3nms_7gpu_nms_gpu_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh, __pyx_t_5numpy_int32_t __pyx_v_device_id); /* proto */\nstatic int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */\nstatic void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */\nstatic PyObject *__pyx_int_4;\nstatic PyObject *__pyx_int_neg_1;\nstatic PyObject *__pyx_slice_;\nstatic PyObject *__pyx_slice__3;\nstatic PyObject *__pyx_slice__4;\nstatic PyObject *__pyx_tuple__2;\nstatic PyObject *__pyx_tuple__5;\nstatic PyObject *__pyx_tuple__6;\nstatic PyObject *__pyx_tuple__7;\nstatic PyObject *__pyx_tuple__8;\nstatic PyObject *__pyx_tuple__9;\nstatic PyObject *__pyx_tuple__10;\nstatic PyObject *__pyx_tuple__11;\nstatic PyObject *__pyx_codeobj__12;\n\n/* \"nms/gpu_nms.pyx\":16\n * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int)\n * \n * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<<\n * np.int32_t device_id=0):\n * cdef int boxes_num = dets.shape[0]\n */\n\n/* Python wrapper */\nstatic PyObject *__pyx_pw_3nms_7gpu_nms_1gpu_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/\nstatic PyMethodDef __pyx_mdef_3nms_7gpu_nms_1gpu_nms = {\"gpu_nms\", (PyCFunction)__pyx_pw_3nms_7gpu_nms_1gpu_nms, METH_VARARGS|METH_KEYWORDS, 0};\nstatic PyObject *__pyx_pw_3nms_7gpu_nms_1gpu_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {\n PyArrayObject *__pyx_v_dets = 0;\n PyObject *__pyx_v_thresh = 0;\n __pyx_t_5numpy_int32_t __pyx_v_device_id;\n PyObject *__pyx_r = 0;\n __Pyx_RefNannyDeclarations\n __Pyx_RefNannySetupContext(\"gpu_nms (wrapper)\", 0);\n {\n static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dets,&__pyx_n_s_thresh,&__pyx_n_s_device_id,0};\n PyObject* values[3] = {0,0,0};\n if (unlikely(__pyx_kwds)) {\n Py_ssize_t kw_args;\n const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);\n switch (pos_args) {\n case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);\n case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);\n case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);\n case 0: break;\n default: goto __pyx_L5_argtuple_error;\n }\n kw_args = PyDict_Size(__pyx_kwds);\n switch (pos_args) {\n case 0:\n if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dets)) != 0)) kw_args--;\n else goto __pyx_L5_argtuple_error;\n case 1:\n if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_thresh)) != 0)) kw_args--;\n else {\n __Pyx_RaiseArgtupleInvalid(\"gpu_nms\", 0, 2, 3, 1); __PYX_ERR(0, 16, __pyx_L3_error)\n }\n case 2:\n if (kw_args > 0) {\n PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_device_id);\n if (value) { values[2] = value; kw_args--; }\n }\n }\n if (unlikely(kw_args > 0)) {\n if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, \"gpu_nms\") < 0)) __PYX_ERR(0, 16, __pyx_L3_error)\n }\n } else {\n switch (PyTuple_GET_SIZE(__pyx_args)) {\n case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);\n case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);\n values[0] = PyTuple_GET_ITEM(__pyx_args, 0);\n break;\n default: goto __pyx_L5_argtuple_error;\n }\n }\n __pyx_v_dets = ((PyArrayObject *)values[0]);\n __pyx_v_thresh = ((PyObject*)values[1]);\n if (values[2]) {\n __pyx_v_device_id = __Pyx_PyInt_As_npy_int32(values[2]); if (unlikely((__pyx_v_device_id == (npy_int32)-1) && PyErr_Occurred())) __PYX_ERR(0, 17, __pyx_L3_error)\n } else {\n __pyx_v_device_id = ((__pyx_t_5numpy_int32_t)0);\n }\n }\n goto __pyx_L4_argument_unpacking_done;\n __pyx_L5_argtuple_error:;\n __Pyx_RaiseArgtupleInvalid(\"gpu_nms\", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 16, __pyx_L3_error)\n __pyx_L3_error:;\n __Pyx_AddTraceback(\"nms.gpu_nms.gpu_nms\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __Pyx_RefNannyFinishContext();\n return NULL;\n __pyx_L4_argument_unpacking_done:;\n if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dets), __pyx_ptype_5numpy_ndarray, 1, \"dets\", 0))) __PYX_ERR(0, 16, __pyx_L1_error)\n if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_thresh), (&PyFloat_Type), 1, \"thresh\", 1))) __PYX_ERR(0, 16, __pyx_L1_error)\n __pyx_r = __pyx_pf_3nms_7gpu_nms_gpu_nms(__pyx_self, __pyx_v_dets, __pyx_v_thresh, __pyx_v_device_id);\n\n /* function exit code */\n goto __pyx_L0;\n __pyx_L1_error:;\n __pyx_r = NULL;\n __pyx_L0:;\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\nstatic PyObject *__pyx_pf_3nms_7gpu_nms_gpu_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh, __pyx_t_5numpy_int32_t __pyx_v_device_id) {\n int __pyx_v_boxes_num;\n int __pyx_v_boxes_dim;\n int __pyx_v_num_out;\n PyArrayObject *__pyx_v_keep = 0;\n PyArrayObject *__pyx_v_scores = 0;\n PyArrayObject *__pyx_v_order = 0;\n PyArrayObject *__pyx_v_sorted_dets = 0;\n __Pyx_LocalBuf_ND __pyx_pybuffernd_dets;\n __Pyx_Buffer __pyx_pybuffer_dets;\n __Pyx_LocalBuf_ND __pyx_pybuffernd_keep;\n __Pyx_Buffer __pyx_pybuffer_keep;\n __Pyx_LocalBuf_ND __pyx_pybuffernd_order;\n __Pyx_Buffer __pyx_pybuffer_order;\n __Pyx_LocalBuf_ND __pyx_pybuffernd_scores;\n __Pyx_Buffer __pyx_pybuffer_scores;\n __Pyx_LocalBuf_ND __pyx_pybuffernd_sorted_dets;\n __Pyx_Buffer __pyx_pybuffer_sorted_dets;\n PyObject *__pyx_r = NULL;\n __Pyx_RefNannyDeclarations\n PyObject *__pyx_t_1 = NULL;\n PyObject *__pyx_t_2 = NULL;\n PyObject *__pyx_t_3 = NULL;\n PyObject *__pyx_t_4 = NULL;\n PyObject *__pyx_t_5 = NULL;\n PyArrayObject *__pyx_t_6 = NULL;\n PyArrayObject *__pyx_t_7 = NULL;\n PyArrayObject *__pyx_t_8 = NULL;\n PyArrayObject *__pyx_t_9 = NULL;\n Py_ssize_t __pyx_t_10;\n int __pyx_t_11;\n Py_ssize_t __pyx_t_12;\n Py_ssize_t __pyx_t_13;\n float __pyx_t_14;\n PyObject *__pyx_t_15 = NULL;\n PyObject *__pyx_t_16 = NULL;\n PyObject *__pyx_t_17 = NULL;\n __Pyx_RefNannySetupContext(\"gpu_nms\", 0);\n __pyx_pybuffer_keep.pybuffer.buf = NULL;\n __pyx_pybuffer_keep.refcount = 0;\n __pyx_pybuffernd_keep.data = NULL;\n __pyx_pybuffernd_keep.rcbuffer = &__pyx_pybuffer_keep;\n __pyx_pybuffer_scores.pybuffer.buf = NULL;\n __pyx_pybuffer_scores.refcount = 0;\n __pyx_pybuffernd_scores.data = NULL;\n __pyx_pybuffernd_scores.rcbuffer = &__pyx_pybuffer_scores;\n __pyx_pybuffer_order.pybuffer.buf = NULL;\n __pyx_pybuffer_order.refcount = 0;\n __pyx_pybuffernd_order.data = NULL;\n __pyx_pybuffernd_order.rcbuffer = &__pyx_pybuffer_order;\n __pyx_pybuffer_sorted_dets.pybuffer.buf = NULL;\n __pyx_pybuffer_sorted_dets.refcount = 0;\n __pyx_pybuffernd_sorted_dets.data = NULL;\n __pyx_pybuffernd_sorted_dets.rcbuffer = &__pyx_pybuffer_sorted_dets;\n __pyx_pybuffer_dets.pybuffer.buf = NULL;\n __pyx_pybuffer_dets.refcount = 0;\n __pyx_pybuffernd_dets.data = NULL;\n __pyx_pybuffernd_dets.rcbuffer = &__pyx_pybuffer_dets;\n {\n __Pyx_BufFmt_StackElem __pyx_stack[1];\n if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_dets.rcbuffer->pybuffer, (PyObject*)__pyx_v_dets, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error)\n }\n __pyx_pybuffernd_dets.diminfo[0].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_dets.diminfo[0].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_dets.diminfo[1].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_dets.diminfo[1].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[1];\n\n /* \"nms/gpu_nms.pyx\":18\n * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh,\n * np.int32_t device_id=0):\n * cdef int boxes_num = dets.shape[0] # <<<<<<<<<<<<<<\n * cdef int boxes_dim = dets.shape[1]\n * cdef int num_out\n */\n __pyx_v_boxes_num = (__pyx_v_dets->dimensions[0]);\n\n /* \"nms/gpu_nms.pyx\":19\n * np.int32_t device_id=0):\n * cdef int boxes_num = dets.shape[0]\n * cdef int boxes_dim = dets.shape[1] # <<<<<<<<<<<<<<\n * cdef int num_out\n * cdef np.ndarray[np.int32_t, ndim=1] \\\n */\n __pyx_v_boxes_dim = (__pyx_v_dets->dimensions[1]);\n\n /* \"nms/gpu_nms.pyx\":22\n * cdef int num_out\n * cdef np.ndarray[np.int32_t, ndim=1] \\\n * keep = np.zeros(boxes_num, dtype=np.int32) # <<<<<<<<<<<<<<\n * cdef np.ndarray[np.float32_t, ndim=1] \\\n * scores = dets[:, 4]\n */\n __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_2);\n __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_boxes_num); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_GIVEREF(__pyx_t_1);\n PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);\n __pyx_t_1 = 0;\n __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_5);\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;\n __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_5);\n __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 22, __pyx_L1_error)\n __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);\n {\n __Pyx_BufFmt_StackElem __pyx_stack[1];\n if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {\n __pyx_v_keep = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_keep.rcbuffer->pybuffer.buf = NULL;\n __PYX_ERR(0, 21, __pyx_L1_error)\n } else {__pyx_pybuffernd_keep.diminfo[0].strides = __pyx_pybuffernd_keep.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_keep.diminfo[0].shape = __pyx_pybuffernd_keep.rcbuffer->pybuffer.shape[0];\n }\n }\n __pyx_t_6 = 0;\n __pyx_v_keep = ((PyArrayObject *)__pyx_t_5);\n __pyx_t_5 = 0;\n\n /* \"nms/gpu_nms.pyx\":24\n * keep = np.zeros(boxes_num, dtype=np.int32)\n * cdef np.ndarray[np.float32_t, ndim=1] \\\n * scores = dets[:, 4] # <<<<<<<<<<<<<<\n * #cdef np.ndarray[np.int_t, ndim=1] \\ // 20160601, by xzn\n * # order = scores.argsort()[::-1]\n */\n __pyx_t_5 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 24, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_5);\n if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 24, __pyx_L1_error)\n __pyx_t_7 = ((PyArrayObject *)__pyx_t_5);\n {\n __Pyx_BufFmt_StackElem __pyx_stack[1];\n if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_scores.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {\n __pyx_v_scores = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_scores.rcbuffer->pybuffer.buf = NULL;\n __PYX_ERR(0, 23, __pyx_L1_error)\n } else {__pyx_pybuffernd_scores.diminfo[0].strides = __pyx_pybuffernd_scores.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_scores.diminfo[0].shape = __pyx_pybuffernd_scores.rcbuffer->pybuffer.shape[0];\n }\n }\n __pyx_t_7 = 0;\n __pyx_v_scores = ((PyArrayObject *)__pyx_t_5);\n __pyx_t_5 = 0;\n\n /* \"nms/gpu_nms.pyx\":28\n * # order = scores.argsort()[::-1]\n * cdef np.ndarray[np.intp_t, ndim=1] \\\n * order = scores.argsort()[::-1] # <<<<<<<<<<<<<<\n * cdef np.ndarray[np.float32_t, ndim=2] \\\n * sorted_dets = dets[order, :]\n */\n __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_scores), __pyx_n_s_argsort); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_t_3 = NULL;\n if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {\n __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);\n if (likely(__pyx_t_3)) {\n PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);\n __Pyx_INCREF(__pyx_t_3);\n __Pyx_INCREF(function);\n __Pyx_DECREF_SET(__pyx_t_1, function);\n }\n }\n if (__pyx_t_3) {\n __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 28, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n } else {\n __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 28, __pyx_L1_error)\n }\n __Pyx_GOTREF(__pyx_t_5);\n __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n __pyx_t_1 = PyObject_GetItem(__pyx_t_5, __pyx_slice__3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;\n if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 28, __pyx_L1_error)\n __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);\n {\n __Pyx_BufFmt_StackElem __pyx_stack[1];\n if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_order.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_intp_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {\n __pyx_v_order = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_order.rcbuffer->pybuffer.buf = NULL;\n __PYX_ERR(0, 27, __pyx_L1_error)\n } else {__pyx_pybuffernd_order.diminfo[0].strides = __pyx_pybuffernd_order.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_order.diminfo[0].shape = __pyx_pybuffernd_order.rcbuffer->pybuffer.shape[0];\n }\n }\n __pyx_t_8 = 0;\n __pyx_v_order = ((PyArrayObject *)__pyx_t_1);\n __pyx_t_1 = 0;\n\n /* \"nms/gpu_nms.pyx\":30\n * order = scores.argsort()[::-1]\n * cdef np.ndarray[np.float32_t, ndim=2] \\\n * sorted_dets = dets[order, :] # <<<<<<<<<<<<<<\n * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id)\n * keep = keep[:num_out]\n */\n __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n __Pyx_INCREF(((PyObject *)__pyx_v_order));\n __Pyx_GIVEREF(((PyObject *)__pyx_v_order));\n PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_order));\n __Pyx_INCREF(__pyx_slice__4);\n __Pyx_GIVEREF(__pyx_slice__4);\n PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_slice__4);\n __pyx_t_5 = PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 30, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_5);\n __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 30, __pyx_L1_error)\n __pyx_t_9 = ((PyArrayObject *)__pyx_t_5);\n {\n __Pyx_BufFmt_StackElem __pyx_stack[1];\n if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {\n __pyx_v_sorted_dets = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.buf = NULL;\n __PYX_ERR(0, 29, __pyx_L1_error)\n } else {__pyx_pybuffernd_sorted_dets.diminfo[0].strides = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sorted_dets.diminfo[0].shape = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sorted_dets.diminfo[1].strides = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sorted_dets.diminfo[1].shape = __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.shape[1];\n }\n }\n __pyx_t_9 = 0;\n __pyx_v_sorted_dets = ((PyArrayObject *)__pyx_t_5);\n __pyx_t_5 = 0;\n\n /* \"nms/gpu_nms.pyx\":31\n * cdef np.ndarray[np.float32_t, ndim=2] \\\n * sorted_dets = dets[order, :]\n * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id) # <<<<<<<<<<<<<<\n * keep = keep[:num_out]\n * return list(order[keep])\n */\n __pyx_t_10 = 0;\n __pyx_t_11 = -1;\n if (__pyx_t_10 < 0) {\n __pyx_t_10 += __pyx_pybuffernd_keep.diminfo[0].shape;\n if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 0;\n } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_keep.diminfo[0].shape)) __pyx_t_11 = 0;\n if (unlikely(__pyx_t_11 != -1)) {\n __Pyx_RaiseBufferIndexError(__pyx_t_11);\n __PYX_ERR(0, 31, __pyx_L1_error)\n }\n __pyx_t_12 = 0;\n __pyx_t_13 = 0;\n __pyx_t_11 = -1;\n if (__pyx_t_12 < 0) {\n __pyx_t_12 += __pyx_pybuffernd_sorted_dets.diminfo[0].shape;\n if (unlikely(__pyx_t_12 < 0)) __pyx_t_11 = 0;\n } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_sorted_dets.diminfo[0].shape)) __pyx_t_11 = 0;\n if (__pyx_t_13 < 0) {\n __pyx_t_13 += __pyx_pybuffernd_sorted_dets.diminfo[1].shape;\n if (unlikely(__pyx_t_13 < 0)) __pyx_t_11 = 1;\n } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_sorted_dets.diminfo[1].shape)) __pyx_t_11 = 1;\n if (unlikely(__pyx_t_11 != -1)) {\n __Pyx_RaiseBufferIndexError(__pyx_t_11);\n __PYX_ERR(0, 31, __pyx_L1_error)\n }\n __pyx_t_14 = __pyx_PyFloat_AsFloat(__pyx_v_thresh); if (unlikely((__pyx_t_14 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L1_error)\n _nms((&(*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int32_t *, __pyx_pybuffernd_keep.rcbuffer->pybuffer.buf, __pyx_t_10, __pyx_pybuffernd_keep.diminfo[0].strides))), (&__pyx_v_num_out), (&(*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_sorted_dets.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_sorted_dets.diminfo[1].strides))), __pyx_v_boxes_num, __pyx_v_boxes_dim, __pyx_t_14, __pyx_v_device_id);\n\n /* \"nms/gpu_nms.pyx\":32\n * sorted_dets = dets[order, :]\n * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id)\n * keep = keep[:num_out] # <<<<<<<<<<<<<<\n * return list(order[keep])\n */\n __pyx_t_5 = __Pyx_PyObject_GetSlice(((PyObject *)__pyx_v_keep), 0, __pyx_v_num_out, NULL, NULL, NULL, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_5);\n if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 32, __pyx_L1_error)\n __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);\n {\n __Pyx_BufFmt_StackElem __pyx_stack[1];\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer);\n __pyx_t_11 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);\n if (unlikely(__pyx_t_11 < 0)) {\n PyErr_Fetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);\n if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_keep.rcbuffer->pybuffer, (PyObject*)__pyx_v_keep, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {\n Py_XDECREF(__pyx_t_15); Py_XDECREF(__pyx_t_16); Py_XDECREF(__pyx_t_17);\n __Pyx_RaiseBufferFallbackError();\n } else {\n PyErr_Restore(__pyx_t_15, __pyx_t_16, __pyx_t_17);\n }\n }\n __pyx_pybuffernd_keep.diminfo[0].strides = __pyx_pybuffernd_keep.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_keep.diminfo[0].shape = __pyx_pybuffernd_keep.rcbuffer->pybuffer.shape[0];\n if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 32, __pyx_L1_error)\n }\n __pyx_t_6 = 0;\n __Pyx_DECREF_SET(__pyx_v_keep, ((PyArrayObject *)__pyx_t_5));\n __pyx_t_5 = 0;\n\n /* \"nms/gpu_nms.pyx\":33\n * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id)\n * keep = keep[:num_out]\n * return list(order[keep]) # <<<<<<<<<<<<<<\n */\n __Pyx_XDECREF(__pyx_r);\n __pyx_t_5 = PyObject_GetItem(((PyObject *)__pyx_v_order), ((PyObject *)__pyx_v_keep)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 33, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_5);\n __pyx_t_1 = PySequence_List(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;\n __pyx_r = __pyx_t_1;\n __pyx_t_1 = 0;\n goto __pyx_L0;\n\n /* \"nms/gpu_nms.pyx\":16\n * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int)\n * \n * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<<\n * np.int32_t device_id=0):\n * cdef int boxes_num = dets.shape[0]\n */\n\n /* function exit code */\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_1);\n __Pyx_XDECREF(__pyx_t_2);\n __Pyx_XDECREF(__pyx_t_3);\n __Pyx_XDECREF(__pyx_t_4);\n __Pyx_XDECREF(__pyx_t_5);\n { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;\n __Pyx_PyThreadState_declare\n __Pyx_PyThreadState_assign\n __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer);\n __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}\n __Pyx_AddTraceback(\"nms.gpu_nms.gpu_nms\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __pyx_r = NULL;\n goto __pyx_L2;\n __pyx_L0:;\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_keep.rcbuffer->pybuffer);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer);\n __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sorted_dets.rcbuffer->pybuffer);\n __pyx_L2:;\n __Pyx_XDECREF((PyObject *)__pyx_v_keep);\n __Pyx_XDECREF((PyObject *)__pyx_v_scores);\n __Pyx_XDECREF((PyObject *)__pyx_v_order);\n __Pyx_XDECREF((PyObject *)__pyx_v_sorted_dets);\n __Pyx_XGIVEREF(__pyx_r);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":197\n * # experimental exception made for __getbuffer__ and __releasebuffer__\n * # -- the details of this may change.\n * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<<\n * # This implementation of getbuffer is geared towards Cython\n * # requirements, and does not yet fullfill the PEP.\n */\n\n/* Python wrapper */\nstatic CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/\nstatic CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {\n int __pyx_r;\n __Pyx_RefNannyDeclarations\n __Pyx_RefNannySetupContext(\"__getbuffer__ (wrapper)\", 0);\n __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));\n\n /* function exit code */\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\nstatic int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {\n int __pyx_v_copy_shape;\n int __pyx_v_i;\n int __pyx_v_ndim;\n int __pyx_v_endian_detector;\n int __pyx_v_little_endian;\n int __pyx_v_t;\n char *__pyx_v_f;\n PyArray_Descr *__pyx_v_descr = 0;\n int __pyx_v_offset;\n int __pyx_v_hasfields;\n int __pyx_r;\n __Pyx_RefNannyDeclarations\n int __pyx_t_1;\n int __pyx_t_2;\n PyObject *__pyx_t_3 = NULL;\n int __pyx_t_4;\n int __pyx_t_5;\n PyObject *__pyx_t_6 = NULL;\n char *__pyx_t_7;\n __Pyx_RefNannySetupContext(\"__getbuffer__\", 0);\n if (__pyx_v_info != NULL) {\n __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);\n __Pyx_GIVEREF(__pyx_v_info->obj);\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":203\n * # of flags\n * \n * if info == NULL: return # <<<<<<<<<<<<<<\n * \n * cdef int copy_shape, i, ndim\n */\n __pyx_t_1 = ((__pyx_v_info == NULL) != 0);\n if (__pyx_t_1) {\n __pyx_r = 0;\n goto __pyx_L0;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":206\n * \n * cdef int copy_shape, i, ndim\n * cdef int endian_detector = 1 # <<<<<<<<<<<<<<\n * cdef bint little_endian = ((&endian_detector)[0] != 0)\n * \n */\n __pyx_v_endian_detector = 1;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":207\n * cdef int copy_shape, i, ndim\n * cdef int endian_detector = 1\n * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<<\n * \n * ndim = PyArray_NDIM(self)\n */\n __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":209\n * cdef bint little_endian = ((&endian_detector)[0] != 0)\n * \n * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<<\n * \n * if sizeof(npy_intp) != sizeof(Py_ssize_t):\n */\n __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":211\n * ndim = PyArray_NDIM(self)\n * \n * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<<\n * copy_shape = 1\n * else:\n */\n __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":212\n * \n * if sizeof(npy_intp) != sizeof(Py_ssize_t):\n * copy_shape = 1 # <<<<<<<<<<<<<<\n * else:\n * copy_shape = 0\n */\n __pyx_v_copy_shape = 1;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":211\n * ndim = PyArray_NDIM(self)\n * \n * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<<\n * copy_shape = 1\n * else:\n */\n goto __pyx_L4;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":214\n * copy_shape = 1\n * else:\n * copy_shape = 0 # <<<<<<<<<<<<<<\n * \n * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)\n */\n /*else*/ {\n __pyx_v_copy_shape = 0;\n }\n __pyx_L4:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":216\n * copy_shape = 0\n * \n * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<<\n * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not C contiguous\")\n */\n __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);\n if (__pyx_t_2) {\n } else {\n __pyx_t_1 = __pyx_t_2;\n goto __pyx_L6_bool_binop_done;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":217\n * \n * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)\n * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<<\n * raise ValueError(u\"ndarray is not C contiguous\")\n * \n */\n __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0);\n __pyx_t_1 = __pyx_t_2;\n __pyx_L6_bool_binop_done:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":216\n * copy_shape = 0\n * \n * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<<\n * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not C contiguous\")\n */\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":218\n * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)\n * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not C contiguous\") # <<<<<<<<<<<<<<\n * \n * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)\n */\n __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_Raise(__pyx_t_3, 0, 0, 0);\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __PYX_ERR(1, 218, __pyx_L1_error)\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":216\n * copy_shape = 0\n * \n * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<<\n * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not C contiguous\")\n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":220\n * raise ValueError(u\"ndarray is not C contiguous\")\n * \n * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<<\n * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not Fortran contiguous\")\n */\n __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);\n if (__pyx_t_2) {\n } else {\n __pyx_t_1 = __pyx_t_2;\n goto __pyx_L9_bool_binop_done;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":221\n * \n * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)\n * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<<\n * raise ValueError(u\"ndarray is not Fortran contiguous\")\n * \n */\n __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0);\n __pyx_t_1 = __pyx_t_2;\n __pyx_L9_bool_binop_done:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":220\n * raise ValueError(u\"ndarray is not C contiguous\")\n * \n * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<<\n * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not Fortran contiguous\")\n */\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":222\n * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)\n * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not Fortran contiguous\") # <<<<<<<<<<<<<<\n * \n * info.buf = PyArray_DATA(self)\n */\n __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 222, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_Raise(__pyx_t_3, 0, 0, 0);\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __PYX_ERR(1, 222, __pyx_L1_error)\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":220\n * raise ValueError(u\"ndarray is not C contiguous\")\n * \n * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<<\n * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not Fortran contiguous\")\n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":224\n * raise ValueError(u\"ndarray is not Fortran contiguous\")\n * \n * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<<\n * info.ndim = ndim\n * if copy_shape:\n */\n __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":225\n * \n * info.buf = PyArray_DATA(self)\n * info.ndim = ndim # <<<<<<<<<<<<<<\n * if copy_shape:\n * # Allocate new buffer for strides and shape info.\n */\n __pyx_v_info->ndim = __pyx_v_ndim;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":226\n * info.buf = PyArray_DATA(self)\n * info.ndim = ndim\n * if copy_shape: # <<<<<<<<<<<<<<\n * # Allocate new buffer for strides and shape info.\n * # This is allocated as one block, strides first.\n */\n __pyx_t_1 = (__pyx_v_copy_shape != 0);\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":229\n * # Allocate new buffer for strides and shape info.\n * # This is allocated as one block, strides first.\n * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<<\n * info.shape = info.strides + ndim\n * for i in range(ndim):\n */\n __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2)));\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":230\n * # This is allocated as one block, strides first.\n * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)\n * info.shape = info.strides + ndim # <<<<<<<<<<<<<<\n * for i in range(ndim):\n * info.strides[i] = PyArray_STRIDES(self)[i]\n */\n __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":231\n * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)\n * info.shape = info.strides + ndim\n * for i in range(ndim): # <<<<<<<<<<<<<<\n * info.strides[i] = PyArray_STRIDES(self)[i]\n * info.shape[i] = PyArray_DIMS(self)[i]\n */\n __pyx_t_4 = __pyx_v_ndim;\n for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {\n __pyx_v_i = __pyx_t_5;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":232\n * info.shape = info.strides + ndim\n * for i in range(ndim):\n * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<<\n * info.shape[i] = PyArray_DIMS(self)[i]\n * else:\n */\n (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":233\n * for i in range(ndim):\n * info.strides[i] = PyArray_STRIDES(self)[i]\n * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<<\n * else:\n * info.strides = PyArray_STRIDES(self)\n */\n (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":226\n * info.buf = PyArray_DATA(self)\n * info.ndim = ndim\n * if copy_shape: # <<<<<<<<<<<<<<\n * # Allocate new buffer for strides and shape info.\n * # This is allocated as one block, strides first.\n */\n goto __pyx_L11;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":235\n * info.shape[i] = PyArray_DIMS(self)[i]\n * else:\n * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<<\n * info.shape = PyArray_DIMS(self)\n * info.suboffsets = NULL\n */\n /*else*/ {\n __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":236\n * else:\n * info.strides = PyArray_STRIDES(self)\n * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<<\n * info.suboffsets = NULL\n * info.itemsize = PyArray_ITEMSIZE(self)\n */\n __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));\n }\n __pyx_L11:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":237\n * info.strides = PyArray_STRIDES(self)\n * info.shape = PyArray_DIMS(self)\n * info.suboffsets = NULL # <<<<<<<<<<<<<<\n * info.itemsize = PyArray_ITEMSIZE(self)\n * info.readonly = not PyArray_ISWRITEABLE(self)\n */\n __pyx_v_info->suboffsets = NULL;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":238\n * info.shape = PyArray_DIMS(self)\n * info.suboffsets = NULL\n * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<<\n * info.readonly = not PyArray_ISWRITEABLE(self)\n * \n */\n __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":239\n * info.suboffsets = NULL\n * info.itemsize = PyArray_ITEMSIZE(self)\n * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<<\n * \n * cdef int t\n */\n __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":242\n * \n * cdef int t\n * cdef char* f = NULL # <<<<<<<<<<<<<<\n * cdef dtype descr = self.descr\n * cdef int offset\n */\n __pyx_v_f = NULL;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":243\n * cdef int t\n * cdef char* f = NULL\n * cdef dtype descr = self.descr # <<<<<<<<<<<<<<\n * cdef int offset\n * \n */\n __pyx_t_3 = ((PyObject *)__pyx_v_self->descr);\n __Pyx_INCREF(__pyx_t_3);\n __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);\n __pyx_t_3 = 0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":246\n * cdef int offset\n * \n * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<<\n * \n * if not hasfields and not copy_shape:\n */\n __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":248\n * cdef bint hasfields = PyDataType_HASFIELDS(descr)\n * \n * if not hasfields and not copy_shape: # <<<<<<<<<<<<<<\n * # do not call releasebuffer\n * info.obj = None\n */\n __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0);\n if (__pyx_t_2) {\n } else {\n __pyx_t_1 = __pyx_t_2;\n goto __pyx_L15_bool_binop_done;\n }\n __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0);\n __pyx_t_1 = __pyx_t_2;\n __pyx_L15_bool_binop_done:;\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":250\n * if not hasfields and not copy_shape:\n * # do not call releasebuffer\n * info.obj = None # <<<<<<<<<<<<<<\n * else:\n * # need to call releasebuffer\n */\n __Pyx_INCREF(Py_None);\n __Pyx_GIVEREF(Py_None);\n __Pyx_GOTREF(__pyx_v_info->obj);\n __Pyx_DECREF(__pyx_v_info->obj);\n __pyx_v_info->obj = Py_None;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":248\n * cdef bint hasfields = PyDataType_HASFIELDS(descr)\n * \n * if not hasfields and not copy_shape: # <<<<<<<<<<<<<<\n * # do not call releasebuffer\n * info.obj = None\n */\n goto __pyx_L14;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":253\n * else:\n * # need to call releasebuffer\n * info.obj = self # <<<<<<<<<<<<<<\n * \n * if not hasfields:\n */\n /*else*/ {\n __Pyx_INCREF(((PyObject *)__pyx_v_self));\n __Pyx_GIVEREF(((PyObject *)__pyx_v_self));\n __Pyx_GOTREF(__pyx_v_info->obj);\n __Pyx_DECREF(__pyx_v_info->obj);\n __pyx_v_info->obj = ((PyObject *)__pyx_v_self);\n }\n __pyx_L14:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":255\n * info.obj = self\n * \n * if not hasfields: # <<<<<<<<<<<<<<\n * t = descr.type_num\n * if ((descr.byteorder == c'>' and little_endian) or\n */\n __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0);\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":256\n * \n * if not hasfields:\n * t = descr.type_num # <<<<<<<<<<<<<<\n * if ((descr.byteorder == c'>' and little_endian) or\n * (descr.byteorder == c'<' and not little_endian)):\n */\n __pyx_t_4 = __pyx_v_descr->type_num;\n __pyx_v_t = __pyx_t_4;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":257\n * if not hasfields:\n * t = descr.type_num\n * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<\n * (descr.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\")\n */\n __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);\n if (!__pyx_t_2) {\n goto __pyx_L20_next_or;\n } else {\n }\n __pyx_t_2 = (__pyx_v_little_endian != 0);\n if (!__pyx_t_2) {\n } else {\n __pyx_t_1 = __pyx_t_2;\n goto __pyx_L19_bool_binop_done;\n }\n __pyx_L20_next_or:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":258\n * t = descr.type_num\n * if ((descr.byteorder == c'>' and little_endian) or\n * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<<\n * raise ValueError(u\"Non-native byte order not supported\")\n * if t == NPY_BYTE: f = \"b\"\n */\n __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);\n if (__pyx_t_2) {\n } else {\n __pyx_t_1 = __pyx_t_2;\n goto __pyx_L19_bool_binop_done;\n }\n __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);\n __pyx_t_1 = __pyx_t_2;\n __pyx_L19_bool_binop_done:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":257\n * if not hasfields:\n * t = descr.type_num\n * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<\n * (descr.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\")\n */\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":259\n * if ((descr.byteorder == c'>' and little_endian) or\n * (descr.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\") # <<<<<<<<<<<<<<\n * if t == NPY_BYTE: f = \"b\"\n * elif t == NPY_UBYTE: f = \"B\"\n */\n __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 259, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_Raise(__pyx_t_3, 0, 0, 0);\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __PYX_ERR(1, 259, __pyx_L1_error)\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":257\n * if not hasfields:\n * t = descr.type_num\n * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<\n * (descr.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\")\n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":260\n * (descr.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\")\n * if t == NPY_BYTE: f = \"b\" # <<<<<<<<<<<<<<\n * elif t == NPY_UBYTE: f = \"B\"\n * elif t == NPY_SHORT: f = \"h\"\n */\n switch (__pyx_v_t) {\n case NPY_BYTE:\n __pyx_v_f = ((char *)\"b\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":261\n * raise ValueError(u\"Non-native byte order not supported\")\n * if t == NPY_BYTE: f = \"b\"\n * elif t == NPY_UBYTE: f = \"B\" # <<<<<<<<<<<<<<\n * elif t == NPY_SHORT: f = \"h\"\n * elif t == NPY_USHORT: f = \"H\"\n */\n case NPY_UBYTE:\n __pyx_v_f = ((char *)\"B\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":262\n * if t == NPY_BYTE: f = \"b\"\n * elif t == NPY_UBYTE: f = \"B\"\n * elif t == NPY_SHORT: f = \"h\" # <<<<<<<<<<<<<<\n * elif t == NPY_USHORT: f = \"H\"\n * elif t == NPY_INT: f = \"i\"\n */\n case NPY_SHORT:\n __pyx_v_f = ((char *)\"h\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":263\n * elif t == NPY_UBYTE: f = \"B\"\n * elif t == NPY_SHORT: f = \"h\"\n * elif t == NPY_USHORT: f = \"H\" # <<<<<<<<<<<<<<\n * elif t == NPY_INT: f = \"i\"\n * elif t == NPY_UINT: f = \"I\"\n */\n case NPY_USHORT:\n __pyx_v_f = ((char *)\"H\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":264\n * elif t == NPY_SHORT: f = \"h\"\n * elif t == NPY_USHORT: f = \"H\"\n * elif t == NPY_INT: f = \"i\" # <<<<<<<<<<<<<<\n * elif t == NPY_UINT: f = \"I\"\n * elif t == NPY_LONG: f = \"l\"\n */\n case NPY_INT:\n __pyx_v_f = ((char *)\"i\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":265\n * elif t == NPY_USHORT: f = \"H\"\n * elif t == NPY_INT: f = \"i\"\n * elif t == NPY_UINT: f = \"I\" # <<<<<<<<<<<<<<\n * elif t == NPY_LONG: f = \"l\"\n * elif t == NPY_ULONG: f = \"L\"\n */\n case NPY_UINT:\n __pyx_v_f = ((char *)\"I\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":266\n * elif t == NPY_INT: f = \"i\"\n * elif t == NPY_UINT: f = \"I\"\n * elif t == NPY_LONG: f = \"l\" # <<<<<<<<<<<<<<\n * elif t == NPY_ULONG: f = \"L\"\n * elif t == NPY_LONGLONG: f = \"q\"\n */\n case NPY_LONG:\n __pyx_v_f = ((char *)\"l\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":267\n * elif t == NPY_UINT: f = \"I\"\n * elif t == NPY_LONG: f = \"l\"\n * elif t == NPY_ULONG: f = \"L\" # <<<<<<<<<<<<<<\n * elif t == NPY_LONGLONG: f = \"q\"\n * elif t == NPY_ULONGLONG: f = \"Q\"\n */\n case NPY_ULONG:\n __pyx_v_f = ((char *)\"L\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":268\n * elif t == NPY_LONG: f = \"l\"\n * elif t == NPY_ULONG: f = \"L\"\n * elif t == NPY_LONGLONG: f = \"q\" # <<<<<<<<<<<<<<\n * elif t == NPY_ULONGLONG: f = \"Q\"\n * elif t == NPY_FLOAT: f = \"f\"\n */\n case NPY_LONGLONG:\n __pyx_v_f = ((char *)\"q\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":269\n * elif t == NPY_ULONG: f = \"L\"\n * elif t == NPY_LONGLONG: f = \"q\"\n * elif t == NPY_ULONGLONG: f = \"Q\" # <<<<<<<<<<<<<<\n * elif t == NPY_FLOAT: f = \"f\"\n * elif t == NPY_DOUBLE: f = \"d\"\n */\n case NPY_ULONGLONG:\n __pyx_v_f = ((char *)\"Q\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":270\n * elif t == NPY_LONGLONG: f = \"q\"\n * elif t == NPY_ULONGLONG: f = \"Q\"\n * elif t == NPY_FLOAT: f = \"f\" # <<<<<<<<<<<<<<\n * elif t == NPY_DOUBLE: f = \"d\"\n * elif t == NPY_LONGDOUBLE: f = \"g\"\n */\n case NPY_FLOAT:\n __pyx_v_f = ((char *)\"f\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":271\n * elif t == NPY_ULONGLONG: f = \"Q\"\n * elif t == NPY_FLOAT: f = \"f\"\n * elif t == NPY_DOUBLE: f = \"d\" # <<<<<<<<<<<<<<\n * elif t == NPY_LONGDOUBLE: f = \"g\"\n * elif t == NPY_CFLOAT: f = \"Zf\"\n */\n case NPY_DOUBLE:\n __pyx_v_f = ((char *)\"d\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":272\n * elif t == NPY_FLOAT: f = \"f\"\n * elif t == NPY_DOUBLE: f = \"d\"\n * elif t == NPY_LONGDOUBLE: f = \"g\" # <<<<<<<<<<<<<<\n * elif t == NPY_CFLOAT: f = \"Zf\"\n * elif t == NPY_CDOUBLE: f = \"Zd\"\n */\n case NPY_LONGDOUBLE:\n __pyx_v_f = ((char *)\"g\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":273\n * elif t == NPY_DOUBLE: f = \"d\"\n * elif t == NPY_LONGDOUBLE: f = \"g\"\n * elif t == NPY_CFLOAT: f = \"Zf\" # <<<<<<<<<<<<<<\n * elif t == NPY_CDOUBLE: f = \"Zd\"\n * elif t == NPY_CLONGDOUBLE: f = \"Zg\"\n */\n case NPY_CFLOAT:\n __pyx_v_f = ((char *)\"Zf\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":274\n * elif t == NPY_LONGDOUBLE: f = \"g\"\n * elif t == NPY_CFLOAT: f = \"Zf\"\n * elif t == NPY_CDOUBLE: f = \"Zd\" # <<<<<<<<<<<<<<\n * elif t == NPY_CLONGDOUBLE: f = \"Zg\"\n * elif t == NPY_OBJECT: f = \"O\"\n */\n case NPY_CDOUBLE:\n __pyx_v_f = ((char *)\"Zd\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":275\n * elif t == NPY_CFLOAT: f = \"Zf\"\n * elif t == NPY_CDOUBLE: f = \"Zd\"\n * elif t == NPY_CLONGDOUBLE: f = \"Zg\" # <<<<<<<<<<<<<<\n * elif t == NPY_OBJECT: f = \"O\"\n * else:\n */\n case NPY_CLONGDOUBLE:\n __pyx_v_f = ((char *)\"Zg\");\n break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":276\n * elif t == NPY_CDOUBLE: f = \"Zd\"\n * elif t == NPY_CLONGDOUBLE: f = \"Zg\"\n * elif t == NPY_OBJECT: f = \"O\" # <<<<<<<<<<<<<<\n * else:\n * raise ValueError(u\"unknown dtype code in numpy.pxd (%d)\" % t)\n */\n case NPY_OBJECT:\n __pyx_v_f = ((char *)\"O\");\n break;\n default:\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":278\n * elif t == NPY_OBJECT: f = \"O\"\n * else:\n * raise ValueError(u\"unknown dtype code in numpy.pxd (%d)\" % t) # <<<<<<<<<<<<<<\n * info.format = f\n * return\n */\n __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_GOTREF(__pyx_t_6);\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_GIVEREF(__pyx_t_6);\n PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);\n __pyx_t_6 = 0;\n __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)\n __Pyx_GOTREF(__pyx_t_6);\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __Pyx_Raise(__pyx_t_6, 0, 0, 0);\n __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;\n __PYX_ERR(1, 278, __pyx_L1_error)\n break;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":279\n * else:\n * raise ValueError(u\"unknown dtype code in numpy.pxd (%d)\" % t)\n * info.format = f # <<<<<<<<<<<<<<\n * return\n * else:\n */\n __pyx_v_info->format = __pyx_v_f;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":280\n * raise ValueError(u\"unknown dtype code in numpy.pxd (%d)\" % t)\n * info.format = f\n * return # <<<<<<<<<<<<<<\n * else:\n * info.format = stdlib.malloc(_buffer_format_string_len)\n */\n __pyx_r = 0;\n goto __pyx_L0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":255\n * info.obj = self\n * \n * if not hasfields: # <<<<<<<<<<<<<<\n * t = descr.type_num\n * if ((descr.byteorder == c'>' and little_endian) or\n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":282\n * return\n * else:\n * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<<\n * info.format[0] = c'^' # Native data types, manual alignment\n * offset = 0\n */\n /*else*/ {\n __pyx_v_info->format = ((char *)malloc(0xFF));\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":283\n * else:\n * info.format = stdlib.malloc(_buffer_format_string_len)\n * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<<\n * offset = 0\n * f = _util_dtypestring(descr, info.format + 1,\n */\n (__pyx_v_info->format[0]) = '^';\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":284\n * info.format = stdlib.malloc(_buffer_format_string_len)\n * info.format[0] = c'^' # Native data types, manual alignment\n * offset = 0 # <<<<<<<<<<<<<<\n * f = _util_dtypestring(descr, info.format + 1,\n * info.format + _buffer_format_string_len,\n */\n __pyx_v_offset = 0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":285\n * info.format[0] = c'^' # Native data types, manual alignment\n * offset = 0\n * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<<\n * info.format + _buffer_format_string_len,\n * &offset)\n */\n __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)\n __pyx_v_f = __pyx_t_7;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":288\n * info.format + _buffer_format_string_len,\n * &offset)\n * f[0] = c'\\0' # Terminate format string # <<<<<<<<<<<<<<\n * \n * def __releasebuffer__(ndarray self, Py_buffer* info):\n */\n (__pyx_v_f[0]) = '\\x00';\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":197\n * # experimental exception made for __getbuffer__ and __releasebuffer__\n * # -- the details of this may change.\n * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<<\n * # This implementation of getbuffer is geared towards Cython\n * # requirements, and does not yet fullfill the PEP.\n */\n\n /* function exit code */\n __pyx_r = 0;\n goto __pyx_L0;\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_3);\n __Pyx_XDECREF(__pyx_t_6);\n __Pyx_AddTraceback(\"numpy.ndarray.__getbuffer__\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __pyx_r = -1;\n if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) {\n __Pyx_GOTREF(__pyx_v_info->obj);\n __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL;\n }\n goto __pyx_L2;\n __pyx_L0:;\n if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) {\n __Pyx_GOTREF(Py_None);\n __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL;\n }\n __pyx_L2:;\n __Pyx_XDECREF((PyObject *)__pyx_v_descr);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":290\n * f[0] = c'\\0' # Terminate format string\n * \n * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<<\n * if PyArray_HASFIELDS(self):\n * stdlib.free(info.format)\n */\n\n/* Python wrapper */\nstatic CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/\nstatic CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {\n __Pyx_RefNannyDeclarations\n __Pyx_RefNannySetupContext(\"__releasebuffer__ (wrapper)\", 0);\n __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));\n\n /* function exit code */\n __Pyx_RefNannyFinishContext();\n}\n\nstatic void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {\n __Pyx_RefNannyDeclarations\n int __pyx_t_1;\n __Pyx_RefNannySetupContext(\"__releasebuffer__\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":291\n * \n * def __releasebuffer__(ndarray self, Py_buffer* info):\n * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<<\n * stdlib.free(info.format)\n * if sizeof(npy_intp) != sizeof(Py_ssize_t):\n */\n __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":292\n * def __releasebuffer__(ndarray self, Py_buffer* info):\n * if PyArray_HASFIELDS(self):\n * stdlib.free(info.format) # <<<<<<<<<<<<<<\n * if sizeof(npy_intp) != sizeof(Py_ssize_t):\n * stdlib.free(info.strides)\n */\n free(__pyx_v_info->format);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":291\n * \n * def __releasebuffer__(ndarray self, Py_buffer* info):\n * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<<\n * stdlib.free(info.format)\n * if sizeof(npy_intp) != sizeof(Py_ssize_t):\n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":293\n * if PyArray_HASFIELDS(self):\n * stdlib.free(info.format)\n * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<<\n * stdlib.free(info.strides)\n * # info.shape was stored after info.strides in the same block\n */\n __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":294\n * stdlib.free(info.format)\n * if sizeof(npy_intp) != sizeof(Py_ssize_t):\n * stdlib.free(info.strides) # <<<<<<<<<<<<<<\n * # info.shape was stored after info.strides in the same block\n * \n */\n free(__pyx_v_info->strides);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":293\n * if PyArray_HASFIELDS(self):\n * stdlib.free(info.format)\n * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<<\n * stdlib.free(info.strides)\n * # info.shape was stored after info.strides in the same block\n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":290\n * f[0] = c'\\0' # Terminate format string\n * \n * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<<\n * if PyArray_HASFIELDS(self):\n * stdlib.free(info.format)\n */\n\n /* function exit code */\n __Pyx_RefNannyFinishContext();\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":770\n * ctypedef npy_cdouble complex_t\n * \n * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(1, a)\n * \n */\n\nstatic CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {\n PyObject *__pyx_r = NULL;\n __Pyx_RefNannyDeclarations\n PyObject *__pyx_t_1 = NULL;\n __Pyx_RefNannySetupContext(\"PyArray_MultiIterNew1\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":771\n * \n * cdef inline object PyArray_MultiIterNew1(a):\n * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<<\n * \n * cdef inline object PyArray_MultiIterNew2(a, b):\n */\n __Pyx_XDECREF(__pyx_r);\n __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 771, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_r = __pyx_t_1;\n __pyx_t_1 = 0;\n goto __pyx_L0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":770\n * ctypedef npy_cdouble complex_t\n * \n * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(1, a)\n * \n */\n\n /* function exit code */\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_1);\n __Pyx_AddTraceback(\"numpy.PyArray_MultiIterNew1\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __pyx_r = 0;\n __pyx_L0:;\n __Pyx_XGIVEREF(__pyx_r);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":773\n * return PyArray_MultiIterNew(1, a)\n * \n * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(2, a, b)\n * \n */\n\nstatic CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {\n PyObject *__pyx_r = NULL;\n __Pyx_RefNannyDeclarations\n PyObject *__pyx_t_1 = NULL;\n __Pyx_RefNannySetupContext(\"PyArray_MultiIterNew2\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":774\n * \n * cdef inline object PyArray_MultiIterNew2(a, b):\n * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<<\n * \n * cdef inline object PyArray_MultiIterNew3(a, b, c):\n */\n __Pyx_XDECREF(__pyx_r);\n __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)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_r = __pyx_t_1;\n __pyx_t_1 = 0;\n goto __pyx_L0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":773\n * return PyArray_MultiIterNew(1, a)\n * \n * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(2, a, b)\n * \n */\n\n /* function exit code */\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_1);\n __Pyx_AddTraceback(\"numpy.PyArray_MultiIterNew2\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __pyx_r = 0;\n __pyx_L0:;\n __Pyx_XGIVEREF(__pyx_r);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":776\n * return PyArray_MultiIterNew(2, a, b)\n * \n * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(3, a, b, c)\n * \n */\n\nstatic CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {\n PyObject *__pyx_r = NULL;\n __Pyx_RefNannyDeclarations\n PyObject *__pyx_t_1 = NULL;\n __Pyx_RefNannySetupContext(\"PyArray_MultiIterNew3\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":777\n * \n * cdef inline object PyArray_MultiIterNew3(a, b, c):\n * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<<\n * \n * cdef inline object PyArray_MultiIterNew4(a, b, c, d):\n */\n __Pyx_XDECREF(__pyx_r);\n __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)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_r = __pyx_t_1;\n __pyx_t_1 = 0;\n goto __pyx_L0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":776\n * return PyArray_MultiIterNew(2, a, b)\n * \n * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(3, a, b, c)\n * \n */\n\n /* function exit code */\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_1);\n __Pyx_AddTraceback(\"numpy.PyArray_MultiIterNew3\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __pyx_r = 0;\n __pyx_L0:;\n __Pyx_XGIVEREF(__pyx_r);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":779\n * return PyArray_MultiIterNew(3, a, b, c)\n * \n * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(4, a, b, c, d)\n * \n */\n\nstatic CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {\n PyObject *__pyx_r = NULL;\n __Pyx_RefNannyDeclarations\n PyObject *__pyx_t_1 = NULL;\n __Pyx_RefNannySetupContext(\"PyArray_MultiIterNew4\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":780\n * \n * cdef inline object PyArray_MultiIterNew4(a, b, c, d):\n * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<<\n * \n * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):\n */\n __Pyx_XDECREF(__pyx_r);\n __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)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_r = __pyx_t_1;\n __pyx_t_1 = 0;\n goto __pyx_L0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":779\n * return PyArray_MultiIterNew(3, a, b, c)\n * \n * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(4, a, b, c, d)\n * \n */\n\n /* function exit code */\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_1);\n __Pyx_AddTraceback(\"numpy.PyArray_MultiIterNew4\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __pyx_r = 0;\n __pyx_L0:;\n __Pyx_XGIVEREF(__pyx_r);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":782\n * return PyArray_MultiIterNew(4, a, b, c, d)\n * \n * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(5, a, b, c, d, e)\n * \n */\n\nstatic 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) {\n PyObject *__pyx_r = NULL;\n __Pyx_RefNannyDeclarations\n PyObject *__pyx_t_1 = NULL;\n __Pyx_RefNannySetupContext(\"PyArray_MultiIterNew5\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":783\n * \n * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):\n * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<<\n * \n * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:\n */\n __Pyx_XDECREF(__pyx_r);\n __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)\n __Pyx_GOTREF(__pyx_t_1);\n __pyx_r = __pyx_t_1;\n __pyx_t_1 = 0;\n goto __pyx_L0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":782\n * return PyArray_MultiIterNew(4, a, b, c, d)\n * \n * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<<\n * return PyArray_MultiIterNew(5, a, b, c, d, e)\n * \n */\n\n /* function exit code */\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_1);\n __Pyx_AddTraceback(\"numpy.PyArray_MultiIterNew5\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __pyx_r = 0;\n __pyx_L0:;\n __Pyx_XGIVEREF(__pyx_r);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":785\n * return PyArray_MultiIterNew(5, a, b, c, d, e)\n * \n * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<<\n * # Recursive utility function used in __getbuffer__ to get format\n * # string. The new location in the format string is returned.\n */\n\nstatic 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) {\n PyArray_Descr *__pyx_v_child = 0;\n int __pyx_v_endian_detector;\n int __pyx_v_little_endian;\n PyObject *__pyx_v_fields = 0;\n PyObject *__pyx_v_childname = NULL;\n PyObject *__pyx_v_new_offset = NULL;\n PyObject *__pyx_v_t = NULL;\n char *__pyx_r;\n __Pyx_RefNannyDeclarations\n PyObject *__pyx_t_1 = NULL;\n Py_ssize_t __pyx_t_2;\n PyObject *__pyx_t_3 = NULL;\n PyObject *__pyx_t_4 = NULL;\n int __pyx_t_5;\n int __pyx_t_6;\n int __pyx_t_7;\n long __pyx_t_8;\n char *__pyx_t_9;\n __Pyx_RefNannySetupContext(\"_util_dtypestring\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":790\n * \n * cdef dtype child\n * cdef int endian_detector = 1 # <<<<<<<<<<<<<<\n * cdef bint little_endian = ((&endian_detector)[0] != 0)\n * cdef tuple fields\n */\n __pyx_v_endian_detector = 1;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":791\n * cdef dtype child\n * cdef int endian_detector = 1\n * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<<\n * cdef tuple fields\n * \n */\n __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":794\n * cdef tuple fields\n * \n * for childname in descr.names: # <<<<<<<<<<<<<<\n * fields = descr.fields[childname]\n * child, new_offset = fields\n */\n if (unlikely(__pyx_v_descr->names == Py_None)) {\n PyErr_SetString(PyExc_TypeError, \"'NoneType' object is not iterable\");\n __PYX_ERR(1, 794, __pyx_L1_error)\n }\n __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;\n for (;;) {\n if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;\n #if CYTHON_COMPILING_IN_CPYTHON\n __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)\n #else\n __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)\n __Pyx_GOTREF(__pyx_t_3);\n #endif\n __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);\n __pyx_t_3 = 0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":795\n * \n * for childname in descr.names:\n * fields = descr.fields[childname] # <<<<<<<<<<<<<<\n * child, new_offset = fields\n * \n */\n if (unlikely(__pyx_v_descr->fields == Py_None)) {\n PyErr_SetString(PyExc_TypeError, \"'NoneType' object is not subscriptable\");\n __PYX_ERR(1, 795, __pyx_L1_error)\n }\n __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)\n __Pyx_GOTREF(__pyx_t_3);\n 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)\n __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));\n __pyx_t_3 = 0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":796\n * for childname in descr.names:\n * fields = descr.fields[childname]\n * child, new_offset = fields # <<<<<<<<<<<<<<\n * \n * if (end - f) - (new_offset - offset[0]) < 15:\n */\n if (likely(__pyx_v_fields != Py_None)) {\n PyObject* sequence = __pyx_v_fields;\n #if CYTHON_COMPILING_IN_CPYTHON\n Py_ssize_t size = Py_SIZE(sequence);\n #else\n Py_ssize_t size = PySequence_Size(sequence);\n #endif\n if (unlikely(size != 2)) {\n if (size > 2) __Pyx_RaiseTooManyValuesError(2);\n else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);\n __PYX_ERR(1, 796, __pyx_L1_error)\n }\n #if CYTHON_COMPILING_IN_CPYTHON\n __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); \n __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); \n __Pyx_INCREF(__pyx_t_3);\n __Pyx_INCREF(__pyx_t_4);\n #else\n __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 796, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 796, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n #endif\n } else {\n __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 796, __pyx_L1_error)\n }\n if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 796, __pyx_L1_error)\n __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));\n __pyx_t_3 = 0;\n __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);\n __pyx_t_4 = 0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":798\n * child, new_offset = fields\n * \n * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<<\n * raise RuntimeError(u\"Format string allocated too short, see comment in numpy.pxd\")\n * \n */\n __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 798, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);\n if (__pyx_t_6) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":799\n * \n * if (end - f) - (new_offset - offset[0]) < 15:\n * raise RuntimeError(u\"Format string allocated too short, see comment in numpy.pxd\") # <<<<<<<<<<<<<<\n * \n * if ((child.byteorder == c'>' and little_endian) or\n */\n __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 799, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_Raise(__pyx_t_3, 0, 0, 0);\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __PYX_ERR(1, 799, __pyx_L1_error)\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":798\n * child, new_offset = fields\n * \n * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<<\n * raise RuntimeError(u\"Format string allocated too short, see comment in numpy.pxd\")\n * \n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":801\n * raise RuntimeError(u\"Format string allocated too short, see comment in numpy.pxd\")\n * \n * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<\n * (child.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\")\n */\n __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);\n if (!__pyx_t_7) {\n goto __pyx_L8_next_or;\n } else {\n }\n __pyx_t_7 = (__pyx_v_little_endian != 0);\n if (!__pyx_t_7) {\n } else {\n __pyx_t_6 = __pyx_t_7;\n goto __pyx_L7_bool_binop_done;\n }\n __pyx_L8_next_or:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":802\n * \n * if ((child.byteorder == c'>' and little_endian) or\n * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<<\n * raise ValueError(u\"Non-native byte order not supported\")\n * # One could encode it in the format string and have Cython\n */\n __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);\n if (__pyx_t_7) {\n } else {\n __pyx_t_6 = __pyx_t_7;\n goto __pyx_L7_bool_binop_done;\n }\n __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);\n __pyx_t_6 = __pyx_t_7;\n __pyx_L7_bool_binop_done:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":801\n * raise RuntimeError(u\"Format string allocated too short, see comment in numpy.pxd\")\n * \n * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<\n * (child.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\")\n */\n if (__pyx_t_6) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":803\n * if ((child.byteorder == c'>' and little_endian) or\n * (child.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\") # <<<<<<<<<<<<<<\n * # One could encode it in the format string and have Cython\n * # complain instead, BUT: < and > in format strings also imply\n */\n __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 803, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_Raise(__pyx_t_3, 0, 0, 0);\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __PYX_ERR(1, 803, __pyx_L1_error)\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":801\n * raise RuntimeError(u\"Format string allocated too short, see comment in numpy.pxd\")\n * \n * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<\n * (child.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\")\n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":813\n * \n * # Output padding bytes\n * while offset[0] < new_offset: # <<<<<<<<<<<<<<\n * f[0] = 120 # \"x\"; pad byte\n * f += 1\n */\n while (1) {\n __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (!__pyx_t_6) break;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":814\n * # Output padding bytes\n * while offset[0] < new_offset:\n * f[0] = 120 # \"x\"; pad byte # <<<<<<<<<<<<<<\n * f += 1\n * offset[0] += 1\n */\n (__pyx_v_f[0]) = 0x78;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":815\n * while offset[0] < new_offset:\n * f[0] = 120 # \"x\"; pad byte\n * f += 1 # <<<<<<<<<<<<<<\n * offset[0] += 1\n * \n */\n __pyx_v_f = (__pyx_v_f + 1);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":816\n * f[0] = 120 # \"x\"; pad byte\n * f += 1\n * offset[0] += 1 # <<<<<<<<<<<<<<\n * \n * offset[0] += child.itemsize\n */\n __pyx_t_8 = 0;\n (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":818\n * offset[0] += 1\n * \n * offset[0] += child.itemsize # <<<<<<<<<<<<<<\n * \n * if not PyDataType_HASFIELDS(child):\n */\n __pyx_t_8 = 0;\n (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":820\n * offset[0] += child.itemsize\n * \n * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<<\n * t = child.type_num\n * if end - f < 5:\n */\n __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);\n if (__pyx_t_6) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":821\n * \n * if not PyDataType_HASFIELDS(child):\n * t = child.type_num # <<<<<<<<<<<<<<\n * if end - f < 5:\n * raise RuntimeError(u\"Format string allocated too short.\")\n */\n __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 821, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);\n __pyx_t_4 = 0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":822\n * if not PyDataType_HASFIELDS(child):\n * t = child.type_num\n * if end - f < 5: # <<<<<<<<<<<<<<\n * raise RuntimeError(u\"Format string allocated too short.\")\n * \n */\n __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);\n if (__pyx_t_6) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":823\n * t = child.type_num\n * if end - f < 5:\n * raise RuntimeError(u\"Format string allocated too short.\") # <<<<<<<<<<<<<<\n * \n * # Until ticket #99 is fixed, use integers to avoid warnings\n */\n __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 823, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __Pyx_Raise(__pyx_t_4, 0, 0, 0);\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __PYX_ERR(1, 823, __pyx_L1_error)\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":822\n * if not PyDataType_HASFIELDS(child):\n * t = child.type_num\n * if end - f < 5: # <<<<<<<<<<<<<<\n * raise RuntimeError(u\"Format string allocated too short.\")\n * \n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":826\n * \n * # Until ticket #99 is fixed, use integers to avoid warnings\n * if t == NPY_BYTE: f[0] = 98 #\"b\" # <<<<<<<<<<<<<<\n * elif t == NPY_UBYTE: f[0] = 66 #\"B\"\n * elif t == NPY_SHORT: f[0] = 104 #\"h\"\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 826, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 826, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 98;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":827\n * # Until ticket #99 is fixed, use integers to avoid warnings\n * if t == NPY_BYTE: f[0] = 98 #\"b\"\n * elif t == NPY_UBYTE: f[0] = 66 #\"B\" # <<<<<<<<<<<<<<\n * elif t == NPY_SHORT: f[0] = 104 #\"h\"\n * elif t == NPY_USHORT: f[0] = 72 #\"H\"\n */\n __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 827, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 827, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 66;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":828\n * if t == NPY_BYTE: f[0] = 98 #\"b\"\n * elif t == NPY_UBYTE: f[0] = 66 #\"B\"\n * elif t == NPY_SHORT: f[0] = 104 #\"h\" # <<<<<<<<<<<<<<\n * elif t == NPY_USHORT: f[0] = 72 #\"H\"\n * elif t == NPY_INT: f[0] = 105 #\"i\"\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 828, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 828, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 0x68;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":829\n * elif t == NPY_UBYTE: f[0] = 66 #\"B\"\n * elif t == NPY_SHORT: f[0] = 104 #\"h\"\n * elif t == NPY_USHORT: f[0] = 72 #\"H\" # <<<<<<<<<<<<<<\n * elif t == NPY_INT: f[0] = 105 #\"i\"\n * elif t == NPY_UINT: f[0] = 73 #\"I\"\n */\n __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 829, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 829, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 72;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":830\n * elif t == NPY_SHORT: f[0] = 104 #\"h\"\n * elif t == NPY_USHORT: f[0] = 72 #\"H\"\n * elif t == NPY_INT: f[0] = 105 #\"i\" # <<<<<<<<<<<<<<\n * elif t == NPY_UINT: f[0] = 73 #\"I\"\n * elif t == NPY_LONG: f[0] = 108 #\"l\"\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 830, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 830, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 0x69;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":831\n * elif t == NPY_USHORT: f[0] = 72 #\"H\"\n * elif t == NPY_INT: f[0] = 105 #\"i\"\n * elif t == NPY_UINT: f[0] = 73 #\"I\" # <<<<<<<<<<<<<<\n * elif t == NPY_LONG: f[0] = 108 #\"l\"\n * elif t == NPY_ULONG: f[0] = 76 #\"L\"\n */\n __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 831, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 831, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 73;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":832\n * elif t == NPY_INT: f[0] = 105 #\"i\"\n * elif t == NPY_UINT: f[0] = 73 #\"I\"\n * elif t == NPY_LONG: f[0] = 108 #\"l\" # <<<<<<<<<<<<<<\n * elif t == NPY_ULONG: f[0] = 76 #\"L\"\n * elif t == NPY_LONGLONG: f[0] = 113 #\"q\"\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 832, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 832, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 0x6C;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":833\n * elif t == NPY_UINT: f[0] = 73 #\"I\"\n * elif t == NPY_LONG: f[0] = 108 #\"l\"\n * elif t == NPY_ULONG: f[0] = 76 #\"L\" # <<<<<<<<<<<<<<\n * elif t == NPY_LONGLONG: f[0] = 113 #\"q\"\n * elif t == NPY_ULONGLONG: f[0] = 81 #\"Q\"\n */\n __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 833, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 833, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 76;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":834\n * elif t == NPY_LONG: f[0] = 108 #\"l\"\n * elif t == NPY_ULONG: f[0] = 76 #\"L\"\n * elif t == NPY_LONGLONG: f[0] = 113 #\"q\" # <<<<<<<<<<<<<<\n * elif t == NPY_ULONGLONG: f[0] = 81 #\"Q\"\n * elif t == NPY_FLOAT: f[0] = 102 #\"f\"\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 834, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 834, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 0x71;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":835\n * elif t == NPY_ULONG: f[0] = 76 #\"L\"\n * elif t == NPY_LONGLONG: f[0] = 113 #\"q\"\n * elif t == NPY_ULONGLONG: f[0] = 81 #\"Q\" # <<<<<<<<<<<<<<\n * elif t == NPY_FLOAT: f[0] = 102 #\"f\"\n * elif t == NPY_DOUBLE: f[0] = 100 #\"d\"\n */\n __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 835, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 81;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":836\n * elif t == NPY_LONGLONG: f[0] = 113 #\"q\"\n * elif t == NPY_ULONGLONG: f[0] = 81 #\"Q\"\n * elif t == NPY_FLOAT: f[0] = 102 #\"f\" # <<<<<<<<<<<<<<\n * elif t == NPY_DOUBLE: f[0] = 100 #\"d\"\n * elif t == NPY_LONGDOUBLE: f[0] = 103 #\"g\"\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 836, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 836, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 0x66;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":837\n * elif t == NPY_ULONGLONG: f[0] = 81 #\"Q\"\n * elif t == NPY_FLOAT: f[0] = 102 #\"f\"\n * elif t == NPY_DOUBLE: f[0] = 100 #\"d\" # <<<<<<<<<<<<<<\n * elif t == NPY_LONGDOUBLE: f[0] = 103 #\"g\"\n * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf\n */\n __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 837, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 0x64;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":838\n * elif t == NPY_FLOAT: f[0] = 102 #\"f\"\n * elif t == NPY_DOUBLE: f[0] = 100 #\"d\"\n * elif t == NPY_LONGDOUBLE: f[0] = 103 #\"g\" # <<<<<<<<<<<<<<\n * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf\n * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 838, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 838, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 0x67;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":839\n * elif t == NPY_DOUBLE: f[0] = 100 #\"d\"\n * elif t == NPY_LONGDOUBLE: f[0] = 103 #\"g\"\n * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<<\n * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd\n * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg\n */\n __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 839, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 839, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 90;\n (__pyx_v_f[1]) = 0x66;\n __pyx_v_f = (__pyx_v_f + 1);\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":840\n * elif t == NPY_LONGDOUBLE: f[0] = 103 #\"g\"\n * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf\n * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<<\n * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg\n * elif t == NPY_OBJECT: f[0] = 79 #\"O\"\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 840, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 840, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 90;\n (__pyx_v_f[1]) = 0x64;\n __pyx_v_f = (__pyx_v_f + 1);\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":841\n * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf\n * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd\n * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<<\n * elif t == NPY_OBJECT: f[0] = 79 #\"O\"\n * else:\n */\n __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 841, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_3);\n __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)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 841, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 90;\n (__pyx_v_f[1]) = 0x67;\n __pyx_v_f = (__pyx_v_f + 1);\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":842\n * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd\n * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg\n * elif t == NPY_OBJECT: f[0] = 79 #\"O\" # <<<<<<<<<<<<<<\n * else:\n * raise ValueError(u\"unknown dtype code in numpy.pxd (%d)\" % t)\n */\n __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 842, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __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)\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 842, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n if (__pyx_t_6) {\n (__pyx_v_f[0]) = 79;\n goto __pyx_L15;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":844\n * elif t == NPY_OBJECT: f[0] = 79 #\"O\"\n * else:\n * raise ValueError(u\"unknown dtype code in numpy.pxd (%d)\" % t) # <<<<<<<<<<<<<<\n * f += 1\n * else:\n */\n /*else*/ {\n __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)\n __Pyx_GOTREF(__pyx_t_3);\n __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_4);\n __Pyx_GIVEREF(__pyx_t_3);\n PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);\n __pyx_t_3 = 0;\n __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)\n __Pyx_GOTREF(__pyx_t_3);\n __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;\n __Pyx_Raise(__pyx_t_3, 0, 0, 0);\n __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;\n __PYX_ERR(1, 844, __pyx_L1_error)\n }\n __pyx_L15:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":845\n * else:\n * raise ValueError(u\"unknown dtype code in numpy.pxd (%d)\" % t)\n * f += 1 # <<<<<<<<<<<<<<\n * else:\n * # Cython ignores struct boundary information (\"T{...}\"),\n */\n __pyx_v_f = (__pyx_v_f + 1);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":820\n * offset[0] += child.itemsize\n * \n * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<<\n * t = child.type_num\n * if end - f < 5:\n */\n goto __pyx_L13;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":849\n * # Cython ignores struct boundary information (\"T{...}\"),\n * # so don't output it\n * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<<\n * return f\n * \n */\n /*else*/ {\n __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)\n __pyx_v_f = __pyx_t_9;\n }\n __pyx_L13:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":794\n * cdef tuple fields\n * \n * for childname in descr.names: # <<<<<<<<<<<<<<\n * fields = descr.fields[childname]\n * child, new_offset = fields\n */\n }\n __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":850\n * # so don't output it\n * f = _util_dtypestring(child, f, end, offset)\n * return f # <<<<<<<<<<<<<<\n * \n * \n */\n __pyx_r = __pyx_v_f;\n goto __pyx_L0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":785\n * return PyArray_MultiIterNew(5, a, b, c, d, e)\n * \n * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<<\n * # Recursive utility function used in __getbuffer__ to get format\n * # string. The new location in the format string is returned.\n */\n\n /* function exit code */\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_1);\n __Pyx_XDECREF(__pyx_t_3);\n __Pyx_XDECREF(__pyx_t_4);\n __Pyx_AddTraceback(\"numpy._util_dtypestring\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n __pyx_r = NULL;\n __pyx_L0:;\n __Pyx_XDECREF((PyObject *)__pyx_v_child);\n __Pyx_XDECREF(__pyx_v_fields);\n __Pyx_XDECREF(__pyx_v_childname);\n __Pyx_XDECREF(__pyx_v_new_offset);\n __Pyx_XDECREF(__pyx_v_t);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":966\n * \n * \n * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<<\n * cdef PyObject* baseptr\n * if base is None:\n */\n\nstatic CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {\n PyObject *__pyx_v_baseptr;\n __Pyx_RefNannyDeclarations\n int __pyx_t_1;\n int __pyx_t_2;\n __Pyx_RefNannySetupContext(\"set_array_base\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":968\n * cdef inline void set_array_base(ndarray arr, object base):\n * cdef PyObject* baseptr\n * if base is None: # <<<<<<<<<<<<<<\n * baseptr = NULL\n * else:\n */\n __pyx_t_1 = (__pyx_v_base == Py_None);\n __pyx_t_2 = (__pyx_t_1 != 0);\n if (__pyx_t_2) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":969\n * cdef PyObject* baseptr\n * if base is None:\n * baseptr = NULL # <<<<<<<<<<<<<<\n * else:\n * Py_INCREF(base) # important to do this before decref below!\n */\n __pyx_v_baseptr = NULL;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":968\n * cdef inline void set_array_base(ndarray arr, object base):\n * cdef PyObject* baseptr\n * if base is None: # <<<<<<<<<<<<<<\n * baseptr = NULL\n * else:\n */\n goto __pyx_L3;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":971\n * baseptr = NULL\n * else:\n * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<<\n * baseptr = base\n * Py_XDECREF(arr.base)\n */\n /*else*/ {\n Py_INCREF(__pyx_v_base);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":972\n * else:\n * Py_INCREF(base) # important to do this before decref below!\n * baseptr = base # <<<<<<<<<<<<<<\n * Py_XDECREF(arr.base)\n * arr.base = baseptr\n */\n __pyx_v_baseptr = ((PyObject *)__pyx_v_base);\n }\n __pyx_L3:;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":973\n * Py_INCREF(base) # important to do this before decref below!\n * baseptr = base\n * Py_XDECREF(arr.base) # <<<<<<<<<<<<<<\n * arr.base = baseptr\n * \n */\n Py_XDECREF(__pyx_v_arr->base);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":974\n * baseptr = base\n * Py_XDECREF(arr.base)\n * arr.base = baseptr # <<<<<<<<<<<<<<\n * \n * cdef inline object get_array_base(ndarray arr):\n */\n __pyx_v_arr->base = __pyx_v_baseptr;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":966\n * \n * \n * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<<\n * cdef PyObject* baseptr\n * if base is None:\n */\n\n /* function exit code */\n __Pyx_RefNannyFinishContext();\n}\n\n/* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":976\n * arr.base = baseptr\n * \n * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<<\n * if arr.base is NULL:\n * return None\n */\n\nstatic CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {\n PyObject *__pyx_r = NULL;\n __Pyx_RefNannyDeclarations\n int __pyx_t_1;\n __Pyx_RefNannySetupContext(\"get_array_base\", 0);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":977\n * \n * cdef inline object get_array_base(ndarray arr):\n * if arr.base is NULL: # <<<<<<<<<<<<<<\n * return None\n * else:\n */\n __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0);\n if (__pyx_t_1) {\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":978\n * cdef inline object get_array_base(ndarray arr):\n * if arr.base is NULL:\n * return None # <<<<<<<<<<<<<<\n * else:\n * return arr.base\n */\n __Pyx_XDECREF(__pyx_r);\n __Pyx_INCREF(Py_None);\n __pyx_r = Py_None;\n goto __pyx_L0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":977\n * \n * cdef inline object get_array_base(ndarray arr):\n * if arr.base is NULL: # <<<<<<<<<<<<<<\n * return None\n * else:\n */\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":980\n * return None\n * else:\n * return arr.base # <<<<<<<<<<<<<<\n */\n /*else*/ {\n __Pyx_XDECREF(__pyx_r);\n __Pyx_INCREF(((PyObject *)__pyx_v_arr->base));\n __pyx_r = ((PyObject *)__pyx_v_arr->base);\n goto __pyx_L0;\n }\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":976\n * arr.base = baseptr\n * \n * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<<\n * if arr.base is NULL:\n * return None\n */\n\n /* function exit code */\n __pyx_L0:;\n __Pyx_XGIVEREF(__pyx_r);\n __Pyx_RefNannyFinishContext();\n return __pyx_r;\n}\n\nstatic PyMethodDef __pyx_methods[] = {\n {0, 0, 0, 0}\n};\n\n#if PY_MAJOR_VERSION >= 3\nstatic struct PyModuleDef __pyx_moduledef = {\n #if PY_VERSION_HEX < 0x03020000\n { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },\n #else\n PyModuleDef_HEAD_INIT,\n #endif\n \"gpu_nms\",\n 0, /* m_doc */\n -1, /* m_size */\n __pyx_methods /* m_methods */,\n NULL, /* m_reload */\n NULL, /* m_traverse */\n NULL, /* m_clear */\n NULL /* m_free */\n};\n#endif\n\nstatic __Pyx_StringTabEntry __pyx_string_tab[] = {\n {&__pyx_kp_s_D_v_zix_caffe_caffe_win_20160523, __pyx_k_D_v_zix_caffe_caffe_win_20160523, sizeof(__pyx_k_D_v_zix_caffe_caffe_win_20160523), 0, 0, 1, 0},\n {&__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},\n {&__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},\n {&__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},\n {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},\n {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},\n {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1},\n {&__pyx_n_s_boxes_dim, __pyx_k_boxes_dim, sizeof(__pyx_k_boxes_dim), 0, 0, 1, 1},\n {&__pyx_n_s_boxes_num, __pyx_k_boxes_num, sizeof(__pyx_k_boxes_num), 0, 0, 1, 1},\n {&__pyx_n_s_dets, __pyx_k_dets, sizeof(__pyx_k_dets), 0, 0, 1, 1},\n {&__pyx_n_s_device_id, __pyx_k_device_id, sizeof(__pyx_k_device_id), 0, 0, 1, 1},\n {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1},\n {&__pyx_n_s_gpu_nms, __pyx_k_gpu_nms, sizeof(__pyx_k_gpu_nms), 0, 0, 1, 1},\n {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},\n {&__pyx_n_s_int32, __pyx_k_int32, sizeof(__pyx_k_int32), 0, 0, 1, 1},\n {&__pyx_n_s_keep, __pyx_k_keep, sizeof(__pyx_k_keep), 0, 0, 1, 1},\n {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},\n {&__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},\n {&__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},\n {&__pyx_n_s_nms_gpu_nms, __pyx_k_nms_gpu_nms, sizeof(__pyx_k_nms_gpu_nms), 0, 0, 1, 1},\n {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},\n {&__pyx_n_s_num_out, __pyx_k_num_out, sizeof(__pyx_k_num_out), 0, 0, 1, 1},\n {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},\n {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1},\n {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},\n {&__pyx_n_s_scores, __pyx_k_scores, sizeof(__pyx_k_scores), 0, 0, 1, 1},\n {&__pyx_n_s_sorted_dets, __pyx_k_sorted_dets, sizeof(__pyx_k_sorted_dets), 0, 0, 1, 1},\n {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},\n {&__pyx_n_s_thresh, __pyx_k_thresh, sizeof(__pyx_k_thresh), 0, 0, 1, 1},\n {&__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},\n {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1},\n {0, 0, 0, 0, 0, 0, 0}\n};\nstatic int __Pyx_InitCachedBuiltins(void) {\n __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 218, __pyx_L1_error)\n __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 231, __pyx_L1_error)\n __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 799, __pyx_L1_error)\n return 0;\n __pyx_L1_error:;\n return -1;\n}\n\nstatic int __Pyx_InitCachedConstants(void) {\n __Pyx_RefNannyDeclarations\n __Pyx_RefNannySetupContext(\"__Pyx_InitCachedConstants\", 0);\n\n /* \"nms/gpu_nms.pyx\":24\n * keep = np.zeros(boxes_num, dtype=np.int32)\n * cdef np.ndarray[np.float32_t, ndim=1] \\\n * scores = dets[:, 4] # <<<<<<<<<<<<<<\n * #cdef np.ndarray[np.int_t, ndim=1] \\ // 20160601, by xzn\n * # order = scores.argsort()[::-1]\n */\n __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 24, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_slice_);\n __Pyx_GIVEREF(__pyx_slice_);\n __pyx_tuple__2 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_4); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 24, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_tuple__2);\n __Pyx_GIVEREF(__pyx_tuple__2);\n\n /* \"nms/gpu_nms.pyx\":28\n * # order = scores.argsort()[::-1]\n * cdef np.ndarray[np.intp_t, ndim=1] \\\n * order = scores.argsort()[::-1] # <<<<<<<<<<<<<<\n * cdef np.ndarray[np.float32_t, ndim=2] \\\n * sorted_dets = dets[order, :]\n */\n __pyx_slice__3 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__3)) __PYX_ERR(0, 28, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_slice__3);\n __Pyx_GIVEREF(__pyx_slice__3);\n\n /* \"nms/gpu_nms.pyx\":30\n * order = scores.argsort()[::-1]\n * cdef np.ndarray[np.float32_t, ndim=2] \\\n * sorted_dets = dets[order, :] # <<<<<<<<<<<<<<\n * _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id)\n * keep = keep[:num_out]\n */\n __pyx_slice__4 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__4)) __PYX_ERR(0, 30, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_slice__4);\n __Pyx_GIVEREF(__pyx_slice__4);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":218\n * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)\n * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not C contiguous\") # <<<<<<<<<<<<<<\n * \n * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)\n */\n __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 218, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_tuple__5);\n __Pyx_GIVEREF(__pyx_tuple__5);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":222\n * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)\n * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):\n * raise ValueError(u\"ndarray is not Fortran contiguous\") # <<<<<<<<<<<<<<\n * \n * info.buf = PyArray_DATA(self)\n */\n __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 222, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_tuple__6);\n __Pyx_GIVEREF(__pyx_tuple__6);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":259\n * if ((descr.byteorder == c'>' and little_endian) or\n * (descr.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\") # <<<<<<<<<<<<<<\n * if t == NPY_BYTE: f = \"b\"\n * elif t == NPY_UBYTE: f = \"B\"\n */\n __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 259, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_tuple__7);\n __Pyx_GIVEREF(__pyx_tuple__7);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":799\n * \n * if (end - f) - (new_offset - offset[0]) < 15:\n * raise RuntimeError(u\"Format string allocated too short, see comment in numpy.pxd\") # <<<<<<<<<<<<<<\n * \n * if ((child.byteorder == c'>' and little_endian) or\n */\n __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 799, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_tuple__8);\n __Pyx_GIVEREF(__pyx_tuple__8);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":803\n * if ((child.byteorder == c'>' and little_endian) or\n * (child.byteorder == c'<' and not little_endian)):\n * raise ValueError(u\"Non-native byte order not supported\") # <<<<<<<<<<<<<<\n * # One could encode it in the format string and have Cython\n * # complain instead, BUT: < and > in format strings also imply\n */\n __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 803, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_tuple__9);\n __Pyx_GIVEREF(__pyx_tuple__9);\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":823\n * t = child.type_num\n * if end - f < 5:\n * raise RuntimeError(u\"Format string allocated too short.\") # <<<<<<<<<<<<<<\n * \n * # Until ticket #99 is fixed, use integers to avoid warnings\n */\n __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 823, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_tuple__10);\n __Pyx_GIVEREF(__pyx_tuple__10);\n\n /* \"nms/gpu_nms.pyx\":16\n * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int)\n * \n * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<<\n * np.int32_t device_id=0):\n * cdef int boxes_num = dets.shape[0]\n */\n __pyx_tuple__11 = PyTuple_Pack(10, __pyx_n_s_dets, __pyx_n_s_thresh, __pyx_n_s_device_id, __pyx_n_s_boxes_num, __pyx_n_s_boxes_dim, __pyx_n_s_num_out, __pyx_n_s_keep, __pyx_n_s_scores, __pyx_n_s_order, __pyx_n_s_sorted_dets); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 16, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_tuple__11);\n __Pyx_GIVEREF(__pyx_tuple__11);\n __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_D_v_zix_caffe_caffe_win_20160523, __pyx_n_s_gpu_nms, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 16, __pyx_L1_error)\n __Pyx_RefNannyFinishContext();\n return 0;\n __pyx_L1_error:;\n __Pyx_RefNannyFinishContext();\n return -1;\n}\n\nstatic int __Pyx_InitGlobals(void) {\n if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);\n __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error)\n __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)\n return 0;\n __pyx_L1_error:;\n return -1;\n}\n\n#if PY_MAJOR_VERSION < 3\nPyMODINIT_FUNC initgpu_nms(void); /*proto*/\nPyMODINIT_FUNC initgpu_nms(void)\n#else\nPyMODINIT_FUNC PyInit_gpu_nms(void); /*proto*/\nPyMODINIT_FUNC PyInit_gpu_nms(void)\n#endif\n{\n PyObject *__pyx_t_1 = NULL;\n __Pyx_RefNannyDeclarations\n #if CYTHON_REFNANNY\n __Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"refnanny\");\n if (!__Pyx_RefNanny) {\n PyErr_Clear();\n __Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"Cython.Runtime.refnanny\");\n if (!__Pyx_RefNanny)\n Py_FatalError(\"failed to import 'refnanny' module\");\n }\n #endif\n __Pyx_RefNannySetupContext(\"PyMODINIT_FUNC PyInit_gpu_nms(void)\", 0);\n if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)\n __pyx_empty_bytes = PyBytes_FromStringAndSize(\"\", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)\n __pyx_empty_unicode = PyUnicode_FromStringAndSize(\"\", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)\n #ifdef __Pyx_CyFunction_USED\n if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n #endif\n #ifdef __Pyx_FusedFunction_USED\n if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n #endif\n #ifdef __Pyx_Coroutine_USED\n if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n #endif\n #ifdef __Pyx_Generator_USED\n if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n #endif\n #ifdef __Pyx_StopAsyncIteration_USED\n if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n #endif\n /*--- Library function declarations ---*/\n /*--- Threads initialization code ---*/\n #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS\n #ifdef WITH_THREAD /* Python build with threading support? */\n PyEval_InitThreads();\n #endif\n #endif\n /*--- Module creation code ---*/\n #if PY_MAJOR_VERSION < 3\n __pyx_m = Py_InitModule4(\"gpu_nms\", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);\n #else\n __pyx_m = PyModule_Create(&__pyx_moduledef);\n #endif\n if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)\n __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)\n Py_INCREF(__pyx_d);\n __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)\n #if CYTHON_COMPILING_IN_PYPY\n Py_INCREF(__pyx_b);\n #endif\n if (PyObject_SetAttrString(__pyx_m, \"__builtins__\", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);\n /*--- Initialize various global constants etc. ---*/\n if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)\n if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n #endif\n if (__pyx_module_is_main_nms__gpu_nms) {\n if (PyObject_SetAttrString(__pyx_m, \"__name__\", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n }\n #if PY_MAJOR_VERSION >= 3\n {\n PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)\n if (!PyDict_GetItemString(modules, \"nms.gpu_nms\")) {\n if (unlikely(PyDict_SetItemString(modules, \"nms.gpu_nms\", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)\n }\n }\n #endif\n /*--- Builtin init code ---*/\n if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n /*--- Constants init code ---*/\n if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n /*--- Global init code ---*/\n /*--- Variable export code ---*/\n /*--- Function export code ---*/\n /*--- Type init code ---*/\n /*--- Type import code ---*/\n __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, \"type\", \n #if CYTHON_COMPILING_IN_PYPY\n sizeof(PyTypeObject),\n #else\n sizeof(PyHeapTypeObject),\n #endif\n 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(2, 9, __pyx_L1_error)\n __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)\n __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(\"numpy\", \"flatiter\", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(1, 168, __pyx_L1_error)\n __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(\"numpy\", \"broadcast\", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(1, 172, __pyx_L1_error)\n __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(\"numpy\", \"ndarray\", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(1, 181, __pyx_L1_error)\n __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(\"numpy\", \"ufunc\", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(1, 861, __pyx_L1_error)\n /*--- Variable import code ---*/\n /*--- Function import code ---*/\n /*--- Execution code ---*/\n #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)\n if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n #endif\n\n /* \"nms/gpu_nms.pyx\":8\n * # --------------------------------------------------------\n * \n * import numpy as np # <<<<<<<<<<<<<<\n * cimport numpy as np\n * \n */\n __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n\n /* \"nms/gpu_nms.pyx\":11\n * cimport numpy as np\n * \n * assert sizeof(int) == sizeof(np.int32_t) # <<<<<<<<<<<<<<\n * \n * cdef extern from \"gpu_nms.hpp\":\n */\n #ifndef CYTHON_WITHOUT_ASSERTIONS\n if (unlikely(!Py_OptimizeFlag)) {\n if (unlikely(!(((sizeof(int)) == (sizeof(__pyx_t_5numpy_int32_t))) != 0))) {\n PyErr_SetNone(PyExc_AssertionError);\n __PYX_ERR(0, 11, __pyx_L1_error)\n }\n }\n #endif\n\n /* \"nms/gpu_nms.pyx\":16\n * void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int)\n * \n * def gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh, # <<<<<<<<<<<<<<\n * np.int32_t device_id=0):\n * cdef int boxes_num = dets.shape[0]\n */\n __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_3nms_7gpu_nms_1gpu_nms, NULL, __pyx_n_s_nms_gpu_nms); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n if (PyDict_SetItem(__pyx_d, __pyx_n_s_gpu_nms, __pyx_t_1) < 0) __PYX_ERR(0, 16, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n\n /* \"nms/gpu_nms.pyx\":1\n * # -------------------------------------------------------- # <<<<<<<<<<<<<<\n * # Faster R-CNN\n * # Copyright (c) 2015 Microsoft\n */\n __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)\n __Pyx_GOTREF(__pyx_t_1);\n if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)\n __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;\n\n /* \"C:/Anaconda2/lib/site-packages/Cython/Includes/numpy/__init__.pxd\":976\n * arr.base = baseptr\n * \n * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<<\n * if arr.base is NULL:\n * return None\n */\n\n /*--- Wrapped vars code ---*/\n\n goto __pyx_L0;\n __pyx_L1_error:;\n __Pyx_XDECREF(__pyx_t_1);\n if (__pyx_m) {\n if (__pyx_d) {\n __Pyx_AddTraceback(\"init nms.gpu_nms\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n }\n Py_DECREF(__pyx_m); __pyx_m = 0;\n } else if (!PyErr_Occurred()) {\n PyErr_SetString(PyExc_ImportError, \"init nms.gpu_nms\");\n }\n __pyx_L0:;\n __Pyx_RefNannyFinishContext();\n #if PY_MAJOR_VERSION < 3\n return;\n #else\n return __pyx_m;\n #endif\n}\n\n/* --- Runtime support code --- */\n/* Refnanny */\n#if CYTHON_REFNANNY\nstatic __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {\n PyObject *m = NULL, *p = NULL;\n void *r = NULL;\n m = PyImport_ImportModule((char *)modname);\n if (!m) goto end;\n p = PyObject_GetAttrString(m, (char *)\"RefNannyAPI\");\n if (!p) goto end;\n r = PyLong_AsVoidPtr(p);\nend:\n Py_XDECREF(p);\n Py_XDECREF(m);\n return (__Pyx_RefNannyAPIStruct *)r;\n}\n#endif\n\n/* RaiseArgTupleInvalid */\nstatic void __Pyx_RaiseArgtupleInvalid(\n const char* func_name,\n int exact,\n Py_ssize_t num_min,\n Py_ssize_t num_max,\n Py_ssize_t num_found)\n{\n Py_ssize_t num_expected;\n const char *more_or_less;\n if (num_found < num_min) {\n num_expected = num_min;\n more_or_less = \"at least\";\n } else {\n num_expected = num_max;\n more_or_less = \"at most\";\n }\n if (exact) {\n more_or_less = \"exactly\";\n }\n PyErr_Format(PyExc_TypeError,\n \"%.200s() takes %.8s %\" CYTHON_FORMAT_SSIZE_T \"d positional argument%.1s (%\" CYTHON_FORMAT_SSIZE_T \"d given)\",\n func_name, more_or_less, num_expected,\n (num_expected == 1) ? \"\" : \"s\", num_found);\n}\n\n/* RaiseDoubleKeywords */\nstatic void __Pyx_RaiseDoubleKeywordsError(\n const char* func_name,\n PyObject* kw_name)\n{\n PyErr_Format(PyExc_TypeError,\n #if PY_MAJOR_VERSION >= 3\n \"%s() got multiple values for keyword argument '%U'\", func_name, kw_name);\n #else\n \"%s() got multiple values for keyword argument '%s'\", func_name,\n PyString_AsString(kw_name));\n #endif\n}\n\n/* ParseKeywords */\nstatic int __Pyx_ParseOptionalKeywords(\n PyObject *kwds,\n PyObject **argnames[],\n PyObject *kwds2,\n PyObject *values[],\n Py_ssize_t num_pos_args,\n const char* function_name)\n{\n PyObject *key = 0, *value = 0;\n Py_ssize_t pos = 0;\n PyObject*** name;\n PyObject*** first_kw_arg = argnames + num_pos_args;\n while (PyDict_Next(kwds, &pos, &key, &value)) {\n name = first_kw_arg;\n while (*name && (**name != key)) name++;\n if (*name) {\n values[name-argnames] = value;\n continue;\n }\n name = first_kw_arg;\n #if PY_MAJOR_VERSION < 3\n if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {\n while (*name) {\n if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))\n && _PyString_Eq(**name, key)) {\n values[name-argnames] = value;\n break;\n }\n name++;\n }\n if (*name) continue;\n else {\n PyObject*** argname = argnames;\n while (argname != first_kw_arg) {\n if ((**argname == key) || (\n (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))\n && _PyString_Eq(**argname, key))) {\n goto arg_passed_twice;\n }\n argname++;\n }\n }\n } else\n #endif\n if (likely(PyUnicode_Check(key))) {\n while (*name) {\n int cmp = (**name == key) ? 0 :\n #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3\n (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :\n #endif\n PyUnicode_Compare(**name, key);\n if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;\n if (cmp == 0) {\n values[name-argnames] = value;\n break;\n }\n name++;\n }\n if (*name) continue;\n else {\n PyObject*** argname = argnames;\n while (argname != first_kw_arg) {\n int cmp = (**argname == key) ? 0 :\n #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3\n (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :\n #endif\n PyUnicode_Compare(**argname, key);\n if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;\n if (cmp == 0) goto arg_passed_twice;\n argname++;\n }\n }\n } else\n goto invalid_keyword_type;\n if (kwds2) {\n if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;\n } else {\n goto invalid_keyword;\n }\n }\n return 0;\narg_passed_twice:\n __Pyx_RaiseDoubleKeywordsError(function_name, key);\n goto bad;\ninvalid_keyword_type:\n PyErr_Format(PyExc_TypeError,\n \"%.200s() keywords must be strings\", function_name);\n goto bad;\ninvalid_keyword:\n PyErr_Format(PyExc_TypeError,\n #if PY_MAJOR_VERSION < 3\n \"%.200s() got an unexpected keyword argument '%.200s'\",\n function_name, PyString_AsString(key));\n #else\n \"%s() got an unexpected keyword argument '%U'\",\n function_name, key);\n #endif\nbad:\n return -1;\n}\n\n/* ArgTypeTest */\nstatic void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {\n PyErr_Format(PyExc_TypeError,\n \"Argument '%.200s' has incorrect type (expected %.200s, got %.200s)\",\n name, type->tp_name, Py_TYPE(obj)->tp_name);\n}\nstatic CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,\n const char *name, int exact)\n{\n if (unlikely(!type)) {\n PyErr_SetString(PyExc_SystemError, \"Missing type object\");\n return 0;\n }\n if (none_allowed && obj == Py_None) return 1;\n else if (exact) {\n if (likely(Py_TYPE(obj) == type)) return 1;\n #if PY_MAJOR_VERSION == 2\n else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;\n #endif\n }\n else {\n if (likely(PyObject_TypeCheck(obj, type))) return 1;\n }\n __Pyx_RaiseArgumentTypeInvalid(name, obj, type);\n return 0;\n}\n\n/* BufferFormatCheck */\nstatic CYTHON_INLINE int __Pyx_IsLittleEndian(void) {\n unsigned int n = 1;\n return *(unsigned char*)(&n) != 0;\n}\nstatic void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,\n __Pyx_BufFmt_StackElem* stack,\n __Pyx_TypeInfo* type) {\n stack[0].field = &ctx->root;\n stack[0].parent_offset = 0;\n ctx->root.type = type;\n ctx->root.name = \"buffer dtype\";\n ctx->root.offset = 0;\n ctx->head = stack;\n ctx->head->field = &ctx->root;\n ctx->fmt_offset = 0;\n ctx->head->parent_offset = 0;\n ctx->new_packmode = '@';\n ctx->enc_packmode = '@';\n ctx->new_count = 1;\n ctx->enc_count = 0;\n ctx->enc_type = 0;\n ctx->is_complex = 0;\n ctx->is_valid_array = 0;\n ctx->struct_alignment = 0;\n while (type->typegroup == 'S') {\n ++ctx->head;\n ctx->head->field = type->fields;\n ctx->head->parent_offset = 0;\n type = type->fields->type;\n }\n}\nstatic int __Pyx_BufFmt_ParseNumber(const char** ts) {\n int count;\n const char* t = *ts;\n if (*t < '0' || *t > '9') {\n return -1;\n } else {\n count = *t++ - '0';\n while (*t >= '0' && *t < '9') {\n count *= 10;\n count += *t++ - '0';\n }\n }\n *ts = t;\n return count;\n}\nstatic int __Pyx_BufFmt_ExpectNumber(const char **ts) {\n int number = __Pyx_BufFmt_ParseNumber(ts);\n if (number == -1)\n PyErr_Format(PyExc_ValueError,\\\n \"Does not understand character buffer dtype format string ('%c')\", **ts);\n return number;\n}\nstatic void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {\n PyErr_Format(PyExc_ValueError,\n \"Unexpected format string character: '%c'\", ch);\n}\nstatic const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {\n switch (ch) {\n case 'c': return \"'char'\";\n case 'b': return \"'signed char'\";\n case 'B': return \"'unsigned char'\";\n case 'h': return \"'short'\";\n case 'H': return \"'unsigned short'\";\n case 'i': return \"'int'\";\n case 'I': return \"'unsigned int'\";\n case 'l': return \"'long'\";\n case 'L': return \"'unsigned long'\";\n case 'q': return \"'long long'\";\n case 'Q': return \"'unsigned long long'\";\n case 'f': return (is_complex ? \"'complex float'\" : \"'float'\");\n case 'd': return (is_complex ? \"'complex double'\" : \"'double'\");\n case 'g': return (is_complex ? \"'complex long double'\" : \"'long double'\");\n case 'T': return \"a struct\";\n case 'O': return \"Python object\";\n case 'P': return \"a pointer\";\n case 's': case 'p': return \"a string\";\n case 0: return \"end\";\n default: return \"unparseable format string\";\n }\n}\nstatic size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {\n switch (ch) {\n case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;\n case 'h': case 'H': return 2;\n case 'i': case 'I': case 'l': case 'L': return 4;\n case 'q': case 'Q': return 8;\n case 'f': return (is_complex ? 8 : 4);\n case 'd': return (is_complex ? 16 : 8);\n case 'g': {\n PyErr_SetString(PyExc_ValueError, \"Python does not define a standard format string size for long double ('g')..\");\n return 0;\n }\n case 'O': case 'P': return sizeof(void*);\n default:\n __Pyx_BufFmt_RaiseUnexpectedChar(ch);\n return 0;\n }\n}\nstatic size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {\n switch (ch) {\n case 'c': case 'b': case 'B': case 's': case 'p': return 1;\n case 'h': case 'H': return sizeof(short);\n case 'i': case 'I': return sizeof(int);\n case 'l': case 'L': return sizeof(long);\n #ifdef HAVE_LONG_LONG\n case 'q': case 'Q': return sizeof(PY_LONG_LONG);\n #endif\n case 'f': return sizeof(float) * (is_complex ? 2 : 1);\n case 'd': return sizeof(double) * (is_complex ? 2 : 1);\n case 'g': return sizeof(long double) * (is_complex ? 2 : 1);\n case 'O': case 'P': return sizeof(void*);\n default: {\n __Pyx_BufFmt_RaiseUnexpectedChar(ch);\n return 0;\n }\n }\n}\ntypedef struct { char c; short x; } __Pyx_st_short;\ntypedef struct { char c; int x; } __Pyx_st_int;\ntypedef struct { char c; long x; } __Pyx_st_long;\ntypedef struct { char c; float x; } __Pyx_st_float;\ntypedef struct { char c; double x; } __Pyx_st_double;\ntypedef struct { char c; long double x; } __Pyx_st_longdouble;\ntypedef struct { char c; void *x; } __Pyx_st_void_p;\n#ifdef HAVE_LONG_LONG\ntypedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;\n#endif\nstatic size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {\n switch (ch) {\n case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;\n case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);\n case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);\n case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);\n#ifdef HAVE_LONG_LONG\n case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);\n#endif\n case 'f': return sizeof(__Pyx_st_float) - sizeof(float);\n case 'd': return sizeof(__Pyx_st_double) - sizeof(double);\n case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);\n case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);\n default:\n __Pyx_BufFmt_RaiseUnexpectedChar(ch);\n return 0;\n }\n}\n/* These are for computing the padding at the end of the struct to align\n on the first member of the struct. This will probably the same as above,\n but we don't have any guarantees.\n */\ntypedef struct { short x; char c; } __Pyx_pad_short;\ntypedef struct { int x; char c; } __Pyx_pad_int;\ntypedef struct { long x; char c; } __Pyx_pad_long;\ntypedef struct { float x; char c; } __Pyx_pad_float;\ntypedef struct { double x; char c; } __Pyx_pad_double;\ntypedef struct { long double x; char c; } __Pyx_pad_longdouble;\ntypedef struct { void *x; char c; } __Pyx_pad_void_p;\n#ifdef HAVE_LONG_LONG\ntypedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;\n#endif\nstatic size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {\n switch (ch) {\n case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;\n case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);\n case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);\n case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);\n#ifdef HAVE_LONG_LONG\n case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);\n#endif\n case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);\n case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);\n case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);\n case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);\n default:\n __Pyx_BufFmt_RaiseUnexpectedChar(ch);\n return 0;\n }\n}\nstatic char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {\n switch (ch) {\n case 'c':\n return 'H';\n case 'b': case 'h': case 'i':\n case 'l': case 'q': case 's': case 'p':\n return 'I';\n case 'B': case 'H': case 'I': case 'L': case 'Q':\n return 'U';\n case 'f': case 'd': case 'g':\n return (is_complex ? 'C' : 'R');\n case 'O':\n return 'O';\n case 'P':\n return 'P';\n default: {\n __Pyx_BufFmt_RaiseUnexpectedChar(ch);\n return 0;\n }\n }\n}\nstatic void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {\n if (ctx->head == NULL || ctx->head->field == &ctx->root) {\n const char* expected;\n const char* quote;\n if (ctx->head == NULL) {\n expected = \"end\";\n quote = \"\";\n } else {\n expected = ctx->head->field->type->name;\n quote = \"'\";\n }\n PyErr_Format(PyExc_ValueError,\n \"Buffer dtype mismatch, expected %s%s%s but got %s\",\n quote, expected, quote,\n __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));\n } else {\n __Pyx_StructField* field = ctx->head->field;\n __Pyx_StructField* parent = (ctx->head - 1)->field;\n PyErr_Format(PyExc_ValueError,\n \"Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'\",\n field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),\n parent->type->name, field->name);\n }\n}\nstatic int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {\n char group;\n size_t size, offset, arraysize = 1;\n if (ctx->enc_type == 0) return 0;\n if (ctx->head->field->type->arraysize[0]) {\n int i, ndim = 0;\n if (ctx->enc_type == 's' || ctx->enc_type == 'p') {\n ctx->is_valid_array = ctx->head->field->type->ndim == 1;\n ndim = 1;\n if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {\n PyErr_Format(PyExc_ValueError,\n \"Expected a dimension of size %zu, got %zu\",\n ctx->head->field->type->arraysize[0], ctx->enc_count);\n return -1;\n }\n }\n if (!ctx->is_valid_array) {\n PyErr_Format(PyExc_ValueError, \"Expected %d dimensions, got %d\",\n ctx->head->field->type->ndim, ndim);\n return -1;\n }\n for (i = 0; i < ctx->head->field->type->ndim; i++) {\n arraysize *= ctx->head->field->type->arraysize[i];\n }\n ctx->is_valid_array = 0;\n ctx->enc_count = 1;\n }\n group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);\n do {\n __Pyx_StructField* field = ctx->head->field;\n __Pyx_TypeInfo* type = field->type;\n if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {\n size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);\n } else {\n size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);\n }\n if (ctx->enc_packmode == '@') {\n size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);\n size_t align_mod_offset;\n if (align_at == 0) return -1;\n align_mod_offset = ctx->fmt_offset % align_at;\n if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;\n if (ctx->struct_alignment == 0)\n ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,\n ctx->is_complex);\n }\n if (type->size != size || type->typegroup != group) {\n if (type->typegroup == 'C' && type->fields != NULL) {\n size_t parent_offset = ctx->head->parent_offset + field->offset;\n ++ctx->head;\n ctx->head->field = type->fields;\n ctx->head->parent_offset = parent_offset;\n continue;\n }\n if ((type->typegroup == 'H' || group == 'H') && type->size == size) {\n } else {\n __Pyx_BufFmt_RaiseExpected(ctx);\n return -1;\n }\n }\n offset = ctx->head->parent_offset + field->offset;\n if (ctx->fmt_offset != offset) {\n PyErr_Format(PyExc_ValueError,\n \"Buffer dtype mismatch; next field is at offset %\" CYTHON_FORMAT_SSIZE_T \"d but %\" CYTHON_FORMAT_SSIZE_T \"d expected\",\n (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);\n return -1;\n }\n ctx->fmt_offset += size;\n if (arraysize)\n ctx->fmt_offset += (arraysize - 1) * size;\n --ctx->enc_count;\n while (1) {\n if (field == &ctx->root) {\n ctx->head = NULL;\n if (ctx->enc_count != 0) {\n __Pyx_BufFmt_RaiseExpected(ctx);\n return -1;\n }\n break;\n }\n ctx->head->field = ++field;\n if (field->type == NULL) {\n --ctx->head;\n field = ctx->head->field;\n continue;\n } else if (field->type->typegroup == 'S') {\n size_t parent_offset = ctx->head->parent_offset + field->offset;\n if (field->type->fields->type == NULL) continue;\n field = field->type->fields;\n ++ctx->head;\n ctx->head->field = field;\n ctx->head->parent_offset = parent_offset;\n break;\n } else {\n break;\n }\n }\n } while (ctx->enc_count);\n ctx->enc_type = 0;\n ctx->is_complex = 0;\n return 0;\n}\nstatic CYTHON_INLINE PyObject *\n__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)\n{\n const char *ts = *tsp;\n int i = 0, number;\n int ndim = ctx->head->field->type->ndim;\n;\n ++ts;\n if (ctx->new_count != 1) {\n PyErr_SetString(PyExc_ValueError,\n \"Cannot handle repeated arrays in format string\");\n return NULL;\n }\n if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;\n while (*ts && *ts != ')') {\n switch (*ts) {\n case ' ': case '\\f': case '\\r': case '\\n': case '\\t': case '\\v': continue;\n default: break;\n }\n number = __Pyx_BufFmt_ExpectNumber(&ts);\n if (number == -1) return NULL;\n if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])\n return PyErr_Format(PyExc_ValueError,\n \"Expected a dimension of size %zu, got %d\",\n ctx->head->field->type->arraysize[i], number);\n if (*ts != ',' && *ts != ')')\n return PyErr_Format(PyExc_ValueError,\n \"Expected a comma in format string, got '%c'\", *ts);\n if (*ts == ',') ts++;\n i++;\n }\n if (i != ndim)\n return PyErr_Format(PyExc_ValueError, \"Expected %d dimension(s), got %d\",\n ctx->head->field->type->ndim, i);\n if (!*ts) {\n PyErr_SetString(PyExc_ValueError,\n \"Unexpected end of format string, expected ')'\");\n return NULL;\n }\n ctx->is_valid_array = 1;\n ctx->new_count = 1;\n *tsp = ++ts;\n return Py_None;\n}\nstatic const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {\n int got_Z = 0;\n while (1) {\n switch(*ts) {\n case 0:\n if (ctx->enc_type != 0 && ctx->head == NULL) {\n __Pyx_BufFmt_RaiseExpected(ctx);\n return NULL;\n }\n if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;\n if (ctx->head != NULL) {\n __Pyx_BufFmt_RaiseExpected(ctx);\n return NULL;\n }\n return ts;\n case ' ':\n case '\\r':\n case '\\n':\n ++ts;\n break;\n case '<':\n if (!__Pyx_IsLittleEndian()) {\n PyErr_SetString(PyExc_ValueError, \"Little-endian buffer not supported on big-endian compiler\");\n return NULL;\n }\n ctx->new_packmode = '=';\n ++ts;\n break;\n case '>':\n case '!':\n if (__Pyx_IsLittleEndian()) {\n PyErr_SetString(PyExc_ValueError, \"Big-endian buffer not supported on little-endian compiler\");\n return NULL;\n }\n ctx->new_packmode = '=';\n ++ts;\n break;\n case '=':\n case '@':\n case '^':\n ctx->new_packmode = *ts++;\n break;\n case 'T':\n {\n const char* ts_after_sub;\n size_t i, struct_count = ctx->new_count;\n size_t struct_alignment = ctx->struct_alignment;\n ctx->new_count = 1;\n ++ts;\n if (*ts != '{') {\n PyErr_SetString(PyExc_ValueError, \"Buffer acquisition: Expected '{' after 'T'\");\n return NULL;\n }\n if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;\n ctx->enc_type = 0;\n ctx->enc_count = 0;\n ctx->struct_alignment = 0;\n ++ts;\n ts_after_sub = ts;\n for (i = 0; i != struct_count; ++i) {\n ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);\n if (!ts_after_sub) return NULL;\n }\n ts = ts_after_sub;\n if (struct_alignment) ctx->struct_alignment = struct_alignment;\n }\n break;\n case '}':\n {\n size_t alignment = ctx->struct_alignment;\n ++ts;\n if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;\n ctx->enc_type = 0;\n if (alignment && ctx->fmt_offset % alignment) {\n ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);\n }\n }\n return ts;\n case 'x':\n if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;\n ctx->fmt_offset += ctx->new_count;\n ctx->new_count = 1;\n ctx->enc_count = 0;\n ctx->enc_type = 0;\n ctx->enc_packmode = ctx->new_packmode;\n ++ts;\n break;\n case 'Z':\n got_Z = 1;\n ++ts;\n if (*ts != 'f' && *ts != 'd' && *ts != 'g') {\n __Pyx_BufFmt_RaiseUnexpectedChar('Z');\n return NULL;\n }\n case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':\n case 'l': case 'L': case 'q': case 'Q':\n case 'f': case 'd': case 'g':\n case 'O': case 'p':\n if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&\n ctx->enc_packmode == ctx->new_packmode) {\n ctx->enc_count += ctx->new_count;\n ctx->new_count = 1;\n got_Z = 0;\n ++ts;\n break;\n }\n case 's':\n if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;\n ctx->enc_count = ctx->new_count;\n ctx->enc_packmode = ctx->new_packmode;\n ctx->enc_type = *ts;\n ctx->is_complex = got_Z;\n ++ts;\n ctx->new_count = 1;\n got_Z = 0;\n break;\n case ':':\n ++ts;\n while(*ts != ':') ++ts;\n ++ts;\n break;\n case '(':\n if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;\n break;\n default:\n {\n int number = __Pyx_BufFmt_ExpectNumber(&ts);\n if (number == -1) return NULL;\n ctx->new_count = (size_t)number;\n }\n }\n }\n}\nstatic CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {\n buf->buf = NULL;\n buf->obj = NULL;\n buf->strides = __Pyx_zeros;\n buf->shape = __Pyx_zeros;\n buf->suboffsets = __Pyx_minusones;\n}\nstatic CYTHON_INLINE int __Pyx_GetBufferAndValidate(\n Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags,\n int nd, int cast, __Pyx_BufFmt_StackElem* stack)\n{\n if (obj == Py_None || obj == NULL) {\n __Pyx_ZeroBuffer(buf);\n return 0;\n }\n buf->buf = NULL;\n if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail;\n if (buf->ndim != nd) {\n PyErr_Format(PyExc_ValueError,\n \"Buffer has wrong number of dimensions (expected %d, got %d)\",\n nd, buf->ndim);\n goto fail;\n }\n if (!cast) {\n __Pyx_BufFmt_Context ctx;\n __Pyx_BufFmt_Init(&ctx, stack, dtype);\n if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;\n }\n if ((unsigned)buf->itemsize != dtype->size) {\n PyErr_Format(PyExc_ValueError,\n \"Item size of buffer (%\" CYTHON_FORMAT_SSIZE_T \"d byte%s) does not match size of '%s' (%\" CYTHON_FORMAT_SSIZE_T \"d byte%s)\",\n buf->itemsize, (buf->itemsize > 1) ? \"s\" : \"\",\n dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? \"s\" : \"\");\n goto fail;\n }\n if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;\n return 0;\nfail:;\n __Pyx_ZeroBuffer(buf);\n return -1;\n}\nstatic CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {\n if (info->buf == NULL) return;\n if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;\n __Pyx_ReleaseBuffer(info);\n}\n\n/* GetBuiltinName */\n static PyObject *__Pyx_GetBuiltinName(PyObject *name) {\n PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);\n if (unlikely(!result)) {\n PyErr_Format(PyExc_NameError,\n#if PY_MAJOR_VERSION >= 3\n \"name '%U' is not defined\", name);\n#else\n \"name '%.200s' is not defined\", PyString_AS_STRING(name));\n#endif\n }\n return result;\n}\n\n/* GetModuleGlobalName */\n static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {\n PyObject *result;\n#if CYTHON_COMPILING_IN_CPYTHON\n result = PyDict_GetItem(__pyx_d, name);\n if (likely(result)) {\n Py_INCREF(result);\n } else {\n#else\n result = PyObject_GetItem(__pyx_d, name);\n if (!result) {\n PyErr_Clear();\n#endif\n result = __Pyx_GetBuiltinName(name);\n }\n return result;\n}\n\n/* PyObjectCall */\n #if CYTHON_COMPILING_IN_CPYTHON\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {\n PyObject *result;\n ternaryfunc call = func->ob_type->tp_call;\n if (unlikely(!call))\n return PyObject_Call(func, arg, kw);\n if (unlikely(Py_EnterRecursiveCall((char*)\" while calling a Python object\")))\n return NULL;\n result = (*call)(func, arg, kw);\n Py_LeaveRecursiveCall();\n if (unlikely(!result) && unlikely(!PyErr_Occurred())) {\n PyErr_SetString(\n PyExc_SystemError,\n \"NULL result without error in PyObject_Call\");\n }\n return result;\n}\n#endif\n\n/* ExtTypeTest */\n static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {\n if (unlikely(!type)) {\n PyErr_SetString(PyExc_SystemError, \"Missing type object\");\n return 0;\n }\n if (likely(PyObject_TypeCheck(obj, type)))\n return 1;\n PyErr_Format(PyExc_TypeError, \"Cannot convert %.200s to %.200s\",\n Py_TYPE(obj)->tp_name, type->tp_name);\n return 0;\n}\n\n/* PyObjectCallMethO */\n #if CYTHON_COMPILING_IN_CPYTHON\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {\n PyObject *self, *result;\n PyCFunction cfunc;\n cfunc = PyCFunction_GET_FUNCTION(func);\n self = PyCFunction_GET_SELF(func);\n if (unlikely(Py_EnterRecursiveCall((char*)\" while calling a Python object\")))\n return NULL;\n result = cfunc(self, arg);\n Py_LeaveRecursiveCall();\n if (unlikely(!result) && unlikely(!PyErr_Occurred())) {\n PyErr_SetString(\n PyExc_SystemError,\n \"NULL result without error in PyObject_Call\");\n }\n return result;\n}\n#endif\n\n/* PyObjectCallOneArg */\n #if CYTHON_COMPILING_IN_CPYTHON\nstatic PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {\n PyObject *result;\n PyObject *args = PyTuple_New(1);\n if (unlikely(!args)) return NULL;\n Py_INCREF(arg);\n PyTuple_SET_ITEM(args, 0, arg);\n result = __Pyx_PyObject_Call(func, args, NULL);\n Py_DECREF(args);\n return result;\n}\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {\n#ifdef __Pyx_CyFunction_USED\n if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {\n#else\n if (likely(PyCFunction_Check(func))) {\n#endif\n if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {\n return __Pyx_PyObject_CallMethO(func, arg);\n }\n }\n return __Pyx__PyObject_CallOneArg(func, arg);\n}\n#else\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {\n PyObject *result;\n PyObject *args = PyTuple_Pack(1, arg);\n if (unlikely(!args)) return NULL;\n result = __Pyx_PyObject_Call(func, args, NULL);\n Py_DECREF(args);\n return result;\n}\n#endif\n\n/* PyObjectCallNoArg */\n #if CYTHON_COMPILING_IN_CPYTHON\nstatic CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {\n#ifdef __Pyx_CyFunction_USED\n if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {\n#else\n if (likely(PyCFunction_Check(func))) {\n#endif\n if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {\n return __Pyx_PyObject_CallMethO(func, NULL);\n }\n }\n return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);\n}\n#endif\n\n/* BufferIndexError */\n static void __Pyx_RaiseBufferIndexError(int axis) {\n PyErr_Format(PyExc_IndexError,\n \"Out of bounds on buffer access (axis %d)\", axis);\n}\n\n/* SliceObject */\n static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,\n Py_ssize_t cstart, Py_ssize_t cstop,\n PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,\n int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {\n#if CYTHON_COMPILING_IN_CPYTHON\n PyMappingMethods* mp;\n#if PY_MAJOR_VERSION < 3\n PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;\n if (likely(ms && ms->sq_slice)) {\n if (!has_cstart) {\n if (_py_start && (*_py_start != Py_None)) {\n cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);\n if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;\n } else\n cstart = 0;\n }\n if (!has_cstop) {\n if (_py_stop && (*_py_stop != Py_None)) {\n cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);\n if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;\n } else\n cstop = PY_SSIZE_T_MAX;\n }\n if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {\n Py_ssize_t l = ms->sq_length(obj);\n if (likely(l >= 0)) {\n if (cstop < 0) {\n cstop += l;\n if (cstop < 0) cstop = 0;\n }\n if (cstart < 0) {\n cstart += l;\n if (cstart < 0) cstart = 0;\n }\n } else {\n if (!PyErr_ExceptionMatches(PyExc_OverflowError))\n goto bad;\n PyErr_Clear();\n }\n }\n return ms->sq_slice(obj, cstart, cstop);\n }\n#endif\n mp = Py_TYPE(obj)->tp_as_mapping;\n if (likely(mp && mp->mp_subscript))\n#endif\n {\n PyObject* result;\n PyObject *py_slice, *py_start, *py_stop;\n if (_py_slice) {\n py_slice = *_py_slice;\n } else {\n PyObject* owned_start = NULL;\n PyObject* owned_stop = NULL;\n if (_py_start) {\n py_start = *_py_start;\n } else {\n if (has_cstart) {\n owned_start = py_start = PyInt_FromSsize_t(cstart);\n if (unlikely(!py_start)) goto bad;\n } else\n py_start = Py_None;\n }\n if (_py_stop) {\n py_stop = *_py_stop;\n } else {\n if (has_cstop) {\n owned_stop = py_stop = PyInt_FromSsize_t(cstop);\n if (unlikely(!py_stop)) {\n Py_XDECREF(owned_start);\n goto bad;\n }\n } else\n py_stop = Py_None;\n }\n py_slice = PySlice_New(py_start, py_stop, Py_None);\n Py_XDECREF(owned_start);\n Py_XDECREF(owned_stop);\n if (unlikely(!py_slice)) goto bad;\n }\n#if CYTHON_COMPILING_IN_CPYTHON\n result = mp->mp_subscript(obj, py_slice);\n#else\n result = PyObject_GetItem(obj, py_slice);\n#endif\n if (!_py_slice) {\n Py_DECREF(py_slice);\n }\n return result;\n }\n PyErr_Format(PyExc_TypeError,\n \"'%.200s' object is unsliceable\", Py_TYPE(obj)->tp_name);\nbad:\n return NULL;\n}\n\n/* BufferFallbackError */\n static void __Pyx_RaiseBufferFallbackError(void) {\n PyErr_SetString(PyExc_ValueError,\n \"Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!\");\n}\n\n/* PyErrFetchRestore */\n #if CYTHON_COMPILING_IN_CPYTHON\nstatic CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {\n PyObject *tmp_type, *tmp_value, *tmp_tb;\n tmp_type = tstate->curexc_type;\n tmp_value = tstate->curexc_value;\n tmp_tb = tstate->curexc_traceback;\n tstate->curexc_type = type;\n tstate->curexc_value = value;\n tstate->curexc_traceback = tb;\n Py_XDECREF(tmp_type);\n Py_XDECREF(tmp_value);\n Py_XDECREF(tmp_tb);\n}\nstatic CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {\n *type = tstate->curexc_type;\n *value = tstate->curexc_value;\n *tb = tstate->curexc_traceback;\n tstate->curexc_type = 0;\n tstate->curexc_value = 0;\n tstate->curexc_traceback = 0;\n}\n#endif\n\n/* RaiseException */\n #if PY_MAJOR_VERSION < 3\nstatic void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,\n CYTHON_UNUSED PyObject *cause) {\n __Pyx_PyThreadState_declare\n Py_XINCREF(type);\n if (!value || value == Py_None)\n value = NULL;\n else\n Py_INCREF(value);\n if (!tb || tb == Py_None)\n tb = NULL;\n else {\n Py_INCREF(tb);\n if (!PyTraceBack_Check(tb)) {\n PyErr_SetString(PyExc_TypeError,\n \"raise: arg 3 must be a traceback or None\");\n goto raise_error;\n }\n }\n if (PyType_Check(type)) {\n#if CYTHON_COMPILING_IN_PYPY\n if (!value) {\n Py_INCREF(Py_None);\n value = Py_None;\n }\n#endif\n PyErr_NormalizeException(&type, &value, &tb);\n } else {\n if (value) {\n PyErr_SetString(PyExc_TypeError,\n \"instance exception may not have a separate value\");\n goto raise_error;\n }\n value = type;\n type = (PyObject*) Py_TYPE(type);\n Py_INCREF(type);\n if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {\n PyErr_SetString(PyExc_TypeError,\n \"raise: exception class must be a subclass of BaseException\");\n goto raise_error;\n }\n }\n __Pyx_PyThreadState_assign\n __Pyx_ErrRestore(type, value, tb);\n return;\nraise_error:\n Py_XDECREF(value);\n Py_XDECREF(type);\n Py_XDECREF(tb);\n return;\n}\n#else\nstatic void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {\n PyObject* owned_instance = NULL;\n if (tb == Py_None) {\n tb = 0;\n } else if (tb && !PyTraceBack_Check(tb)) {\n PyErr_SetString(PyExc_TypeError,\n \"raise: arg 3 must be a traceback or None\");\n goto bad;\n }\n if (value == Py_None)\n value = 0;\n if (PyExceptionInstance_Check(type)) {\n if (value) {\n PyErr_SetString(PyExc_TypeError,\n \"instance exception may not have a separate value\");\n goto bad;\n }\n value = type;\n type = (PyObject*) Py_TYPE(value);\n } else if (PyExceptionClass_Check(type)) {\n PyObject *instance_class = NULL;\n if (value && PyExceptionInstance_Check(value)) {\n instance_class = (PyObject*) Py_TYPE(value);\n if (instance_class != type) {\n int is_subclass = PyObject_IsSubclass(instance_class, type);\n if (!is_subclass) {\n instance_class = NULL;\n } else if (unlikely(is_subclass == -1)) {\n goto bad;\n } else {\n type = instance_class;\n }\n }\n }\n if (!instance_class) {\n PyObject *args;\n if (!value)\n args = PyTuple_New(0);\n else if (PyTuple_Check(value)) {\n Py_INCREF(value);\n args = value;\n } else\n args = PyTuple_Pack(1, value);\n if (!args)\n goto bad;\n owned_instance = PyObject_Call(type, args, NULL);\n Py_DECREF(args);\n if (!owned_instance)\n goto bad;\n value = owned_instance;\n if (!PyExceptionInstance_Check(value)) {\n PyErr_Format(PyExc_TypeError,\n \"calling %R should have returned an instance of \"\n \"BaseException, not %R\",\n type, Py_TYPE(value));\n goto bad;\n }\n }\n } else {\n PyErr_SetString(PyExc_TypeError,\n \"raise: exception class must be a subclass of BaseException\");\n goto bad;\n }\n#if PY_VERSION_HEX >= 0x03030000\n if (cause) {\n#else\n if (cause && cause != Py_None) {\n#endif\n PyObject *fixed_cause;\n if (cause == Py_None) {\n fixed_cause = NULL;\n } else if (PyExceptionClass_Check(cause)) {\n fixed_cause = PyObject_CallObject(cause, NULL);\n if (fixed_cause == NULL)\n goto bad;\n } else if (PyExceptionInstance_Check(cause)) {\n fixed_cause = cause;\n Py_INCREF(fixed_cause);\n } else {\n PyErr_SetString(PyExc_TypeError,\n \"exception causes must derive from \"\n \"BaseException\");\n goto bad;\n }\n PyException_SetCause(value, fixed_cause);\n }\n PyErr_SetObject(type, value);\n if (tb) {\n#if CYTHON_COMPILING_IN_PYPY\n PyObject *tmp_type, *tmp_value, *tmp_tb;\n PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);\n Py_INCREF(tb);\n PyErr_Restore(tmp_type, tmp_value, tb);\n Py_XDECREF(tmp_tb);\n#else\n PyThreadState *tstate = PyThreadState_GET();\n PyObject* tmp_tb = tstate->curexc_traceback;\n if (tb != tmp_tb) {\n Py_INCREF(tb);\n tstate->curexc_traceback = tb;\n Py_XDECREF(tmp_tb);\n }\n#endif\n }\nbad:\n Py_XDECREF(owned_instance);\n return;\n}\n#endif\n\n/* RaiseTooManyValuesToUnpack */\n static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {\n PyErr_Format(PyExc_ValueError,\n \"too many values to unpack (expected %\" CYTHON_FORMAT_SSIZE_T \"d)\", expected);\n}\n\n/* RaiseNeedMoreValuesToUnpack */\n static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {\n PyErr_Format(PyExc_ValueError,\n \"need more than %\" CYTHON_FORMAT_SSIZE_T \"d value%.1s to unpack\",\n index, (index == 1) ? \"\" : \"s\");\n}\n\n/* RaiseNoneIterError */\n static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {\n PyErr_SetString(PyExc_TypeError, \"'NoneType' object is not iterable\");\n}\n\n/* Import */\n static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {\n PyObject *empty_list = 0;\n PyObject *module = 0;\n PyObject *global_dict = 0;\n PyObject *empty_dict = 0;\n PyObject *list;\n #if PY_VERSION_HEX < 0x03030000\n PyObject *py_import;\n py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);\n if (!py_import)\n goto bad;\n #endif\n if (from_list)\n list = from_list;\n else {\n empty_list = PyList_New(0);\n if (!empty_list)\n goto bad;\n list = empty_list;\n }\n global_dict = PyModule_GetDict(__pyx_m);\n if (!global_dict)\n goto bad;\n empty_dict = PyDict_New();\n if (!empty_dict)\n goto bad;\n {\n #if PY_MAJOR_VERSION >= 3\n if (level == -1) {\n if (strchr(__Pyx_MODULE_NAME, '.')) {\n #if PY_VERSION_HEX < 0x03030000\n PyObject *py_level = PyInt_FromLong(1);\n if (!py_level)\n goto bad;\n module = PyObject_CallFunctionObjArgs(py_import,\n name, global_dict, empty_dict, list, py_level, NULL);\n Py_DECREF(py_level);\n #else\n module = PyImport_ImportModuleLevelObject(\n name, global_dict, empty_dict, list, 1);\n #endif\n if (!module) {\n if (!PyErr_ExceptionMatches(PyExc_ImportError))\n goto bad;\n PyErr_Clear();\n }\n }\n level = 0;\n }\n #endif\n if (!module) {\n #if PY_VERSION_HEX < 0x03030000\n PyObject *py_level = PyInt_FromLong(level);\n if (!py_level)\n goto bad;\n module = PyObject_CallFunctionObjArgs(py_import,\n name, global_dict, empty_dict, list, py_level, NULL);\n Py_DECREF(py_level);\n #else\n module = PyImport_ImportModuleLevelObject(\n name, global_dict, empty_dict, list, level);\n #endif\n }\n }\nbad:\n #if PY_VERSION_HEX < 0x03030000\n Py_XDECREF(py_import);\n #endif\n Py_XDECREF(empty_list);\n Py_XDECREF(empty_dict);\n return module;\n}\n\n/* CodeObjectCache */\n static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {\n int start = 0, mid = 0, end = count - 1;\n if (end >= 0 && code_line > entries[end].code_line) {\n return count;\n }\n while (start < end) {\n mid = start + (end - start) / 2;\n if (code_line < entries[mid].code_line) {\n end = mid;\n } else if (code_line > entries[mid].code_line) {\n start = mid + 1;\n } else {\n return mid;\n }\n }\n if (code_line <= entries[mid].code_line) {\n return mid;\n } else {\n return mid + 1;\n }\n}\nstatic PyCodeObject *__pyx_find_code_object(int code_line) {\n PyCodeObject* code_object;\n int pos;\n if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {\n return NULL;\n }\n pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);\n if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {\n return NULL;\n }\n code_object = __pyx_code_cache.entries[pos].code_object;\n Py_INCREF(code_object);\n return code_object;\n}\nstatic void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {\n int pos, i;\n __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;\n if (unlikely(!code_line)) {\n return;\n }\n if (unlikely(!entries)) {\n entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));\n if (likely(entries)) {\n __pyx_code_cache.entries = entries;\n __pyx_code_cache.max_count = 64;\n __pyx_code_cache.count = 1;\n entries[0].code_line = code_line;\n entries[0].code_object = code_object;\n Py_INCREF(code_object);\n }\n return;\n }\n pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);\n if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {\n PyCodeObject* tmp = entries[pos].code_object;\n entries[pos].code_object = code_object;\n Py_DECREF(tmp);\n return;\n }\n if (__pyx_code_cache.count == __pyx_code_cache.max_count) {\n int new_max = __pyx_code_cache.max_count + 64;\n entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(\n __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));\n if (unlikely(!entries)) {\n return;\n }\n __pyx_code_cache.entries = entries;\n __pyx_code_cache.max_count = new_max;\n }\n for (i=__pyx_code_cache.count; i>pos; i--) {\n entries[i] = entries[i-1];\n }\n entries[pos].code_line = code_line;\n entries[pos].code_object = code_object;\n __pyx_code_cache.count++;\n Py_INCREF(code_object);\n}\n\n/* AddTraceback */\n #include \"compile.h\"\n#include \"frameobject.h\"\n#include \"traceback.h\"\nstatic PyCodeObject* __Pyx_CreateCodeObjectForTraceback(\n const char *funcname, int c_line,\n int py_line, const char *filename) {\n PyCodeObject *py_code = 0;\n PyObject *py_srcfile = 0;\n PyObject *py_funcname = 0;\n #if PY_MAJOR_VERSION < 3\n py_srcfile = PyString_FromString(filename);\n #else\n py_srcfile = PyUnicode_FromString(filename);\n #endif\n if (!py_srcfile) goto bad;\n if (c_line) {\n #if PY_MAJOR_VERSION < 3\n py_funcname = PyString_FromFormat( \"%s (%s:%d)\", funcname, __pyx_cfilenm, c_line);\n #else\n py_funcname = PyUnicode_FromFormat( \"%s (%s:%d)\", funcname, __pyx_cfilenm, c_line);\n #endif\n }\n else {\n #if PY_MAJOR_VERSION < 3\n py_funcname = PyString_FromString(funcname);\n #else\n py_funcname = PyUnicode_FromString(funcname);\n #endif\n }\n if (!py_funcname) goto bad;\n py_code = __Pyx_PyCode_New(\n 0,\n 0,\n 0,\n 0,\n 0,\n __pyx_empty_bytes, /*PyObject *code,*/\n __pyx_empty_tuple, /*PyObject *consts,*/\n __pyx_empty_tuple, /*PyObject *names,*/\n __pyx_empty_tuple, /*PyObject *varnames,*/\n __pyx_empty_tuple, /*PyObject *freevars,*/\n __pyx_empty_tuple, /*PyObject *cellvars,*/\n py_srcfile, /*PyObject *filename,*/\n py_funcname, /*PyObject *name,*/\n py_line,\n __pyx_empty_bytes /*PyObject *lnotab*/\n );\n Py_DECREF(py_srcfile);\n Py_DECREF(py_funcname);\n return py_code;\nbad:\n Py_XDECREF(py_srcfile);\n Py_XDECREF(py_funcname);\n return NULL;\n}\nstatic void __Pyx_AddTraceback(const char *funcname, int c_line,\n int py_line, const char *filename) {\n PyCodeObject *py_code = 0;\n PyFrameObject *py_frame = 0;\n py_code = __pyx_find_code_object(c_line ? c_line : py_line);\n if (!py_code) {\n py_code = __Pyx_CreateCodeObjectForTraceback(\n funcname, c_line, py_line, filename);\n if (!py_code) goto bad;\n __pyx_insert_code_object(c_line ? c_line : py_line, py_code);\n }\n py_frame = PyFrame_New(\n PyThreadState_GET(), /*PyThreadState *tstate,*/\n py_code, /*PyCodeObject *code,*/\n __pyx_d, /*PyObject *globals,*/\n 0 /*PyObject *locals*/\n );\n if (!py_frame) goto bad;\n py_frame->f_lineno = py_line;\n PyTraceBack_Here(py_frame);\nbad:\n Py_XDECREF(py_code);\n Py_XDECREF(py_frame);\n}\n\n#if PY_MAJOR_VERSION < 3\nstatic int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {\n if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);\n if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);\n PyErr_Format(PyExc_TypeError, \"'%.200s' does not have the buffer interface\", Py_TYPE(obj)->tp_name);\n return -1;\n}\nstatic void __Pyx_ReleaseBuffer(Py_buffer *view) {\n PyObject *obj = view->obj;\n if (!obj) return;\n if (PyObject_CheckBuffer(obj)) {\n PyBuffer_Release(view);\n return;\n }\n if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; }\n Py_DECREF(obj);\n view->obj = NULL;\n}\n#endif\n\n\n /* CIntFromPyVerify */\n #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\\\n __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)\n#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\\\n __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)\n#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\\\n {\\\n func_type value = func_value;\\\n if (sizeof(target_type) < sizeof(func_type)) {\\\n if (unlikely(value != (func_type) (target_type) value)) {\\\n func_type zero = 0;\\\n if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\\\n return (target_type) -1;\\\n if (is_unsigned && unlikely(value < zero))\\\n goto raise_neg_overflow;\\\n else\\\n goto raise_overflow;\\\n }\\\n }\\\n return (target_type) value;\\\n }\n\n/* CIntToPy */\n static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {\n const int neg_one = (int) -1, const_zero = (int) 0;\n const int is_unsigned = neg_one > const_zero;\n if (is_unsigned) {\n if (sizeof(int) < sizeof(long)) {\n return PyInt_FromLong((long) value);\n } else if (sizeof(int) <= sizeof(unsigned long)) {\n return PyLong_FromUnsignedLong((unsigned long) value);\n } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {\n return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);\n }\n } else {\n if (sizeof(int) <= sizeof(long)) {\n return PyInt_FromLong((long) value);\n } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {\n return PyLong_FromLongLong((PY_LONG_LONG) value);\n }\n }\n {\n int one = 1; int little = (int)*(unsigned char *)&one;\n unsigned char *bytes = (unsigned char *)&value;\n return _PyLong_FromByteArray(bytes, sizeof(int),\n little, !is_unsigned);\n }\n}\n\n/* None */\n #if CYTHON_CCOMPLEX\n #ifdef __cplusplus\n static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {\n return ::std::complex< float >(x, y);\n }\n #else\n static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {\n return x + y*(__pyx_t_float_complex)_Complex_I;\n }\n #endif\n#else\n static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {\n __pyx_t_float_complex z;\n z.real = x;\n z.imag = y;\n return z;\n }\n#endif\n\n/* None */\n #if CYTHON_CCOMPLEX\n#else\n static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) {\n return (a.real == b.real) && (a.imag == b.imag);\n }\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) {\n __pyx_t_float_complex z;\n z.real = a.real + b.real;\n z.imag = a.imag + b.imag;\n return z;\n }\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) {\n __pyx_t_float_complex z;\n z.real = a.real - b.real;\n z.imag = a.imag - b.imag;\n return z;\n }\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) {\n __pyx_t_float_complex z;\n z.real = a.real * b.real - a.imag * b.imag;\n z.imag = a.real * b.imag + a.imag * b.real;\n return z;\n }\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) {\n __pyx_t_float_complex z;\n float denom = b.real * b.real + b.imag * b.imag;\n z.real = (a.real * b.real + a.imag * b.imag) / denom;\n z.imag = (a.imag * b.real - a.real * b.imag) / denom;\n return z;\n }\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) {\n __pyx_t_float_complex z;\n z.real = -a.real;\n z.imag = -a.imag;\n return z;\n }\n static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) {\n return (a.real == 0) && (a.imag == 0);\n }\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) {\n __pyx_t_float_complex z;\n z.real = a.real;\n z.imag = -a.imag;\n return z;\n }\n #if 1\n static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) {\n #if !defined(HAVE_HYPOT) || defined(_MSC_VER)\n return sqrtf(z.real*z.real + z.imag*z.imag);\n #else\n return hypotf(z.real, z.imag);\n #endif\n }\n static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) {\n __pyx_t_float_complex z;\n float r, lnr, theta, z_r, z_theta;\n if (b.imag == 0 && b.real == (int)b.real) {\n if (b.real < 0) {\n float denom = a.real * a.real + a.imag * a.imag;\n a.real = a.real / denom;\n a.imag = -a.imag / denom;\n b.real = -b.real;\n }\n switch ((int)b.real) {\n case 0:\n z.real = 1;\n z.imag = 0;\n return z;\n case 1:\n return a;\n case 2:\n z = __Pyx_c_prodf(a, a);\n return __Pyx_c_prodf(a, a);\n case 3:\n z = __Pyx_c_prodf(a, a);\n return __Pyx_c_prodf(z, a);\n case 4:\n z = __Pyx_c_prodf(a, a);\n return __Pyx_c_prodf(z, z);\n }\n }\n if (a.imag == 0) {\n if (a.real == 0) {\n return a;\n }\n r = a.real;\n theta = 0;\n } else {\n r = __Pyx_c_absf(a);\n theta = atan2f(a.imag, a.real);\n }\n lnr = logf(r);\n z_r = expf(lnr * b.real - theta * b.imag);\n z_theta = theta * b.real + lnr * b.imag;\n z.real = z_r * cosf(z_theta);\n z.imag = z_r * sinf(z_theta);\n return z;\n }\n #endif\n#endif\n\n/* None */\n #if CYTHON_CCOMPLEX\n #ifdef __cplusplus\n static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {\n return ::std::complex< double >(x, y);\n }\n #else\n static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {\n return x + y*(__pyx_t_double_complex)_Complex_I;\n }\n #endif\n#else\n static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {\n __pyx_t_double_complex z;\n z.real = x;\n z.imag = y;\n return z;\n }\n#endif\n\n/* None */\n #if CYTHON_CCOMPLEX\n#else\n static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) {\n return (a.real == b.real) && (a.imag == b.imag);\n }\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) {\n __pyx_t_double_complex z;\n z.real = a.real + b.real;\n z.imag = a.imag + b.imag;\n return z;\n }\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) {\n __pyx_t_double_complex z;\n z.real = a.real - b.real;\n z.imag = a.imag - b.imag;\n return z;\n }\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) {\n __pyx_t_double_complex z;\n z.real = a.real * b.real - a.imag * b.imag;\n z.imag = a.real * b.imag + a.imag * b.real;\n return z;\n }\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) {\n __pyx_t_double_complex z;\n double denom = b.real * b.real + b.imag * b.imag;\n z.real = (a.real * b.real + a.imag * b.imag) / denom;\n z.imag = (a.imag * b.real - a.real * b.imag) / denom;\n return z;\n }\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) {\n __pyx_t_double_complex z;\n z.real = -a.real;\n z.imag = -a.imag;\n return z;\n }\n static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) {\n return (a.real == 0) && (a.imag == 0);\n }\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) {\n __pyx_t_double_complex z;\n z.real = a.real;\n z.imag = -a.imag;\n return z;\n }\n #if 1\n static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) {\n #if !defined(HAVE_HYPOT) || defined(_MSC_VER)\n return sqrt(z.real*z.real + z.imag*z.imag);\n #else\n return hypot(z.real, z.imag);\n #endif\n }\n static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) {\n __pyx_t_double_complex z;\n double r, lnr, theta, z_r, z_theta;\n if (b.imag == 0 && b.real == (int)b.real) {\n if (b.real < 0) {\n double denom = a.real * a.real + a.imag * a.imag;\n a.real = a.real / denom;\n a.imag = -a.imag / denom;\n b.real = -b.real;\n }\n switch ((int)b.real) {\n case 0:\n z.real = 1;\n z.imag = 0;\n return z;\n case 1:\n return a;\n case 2:\n z = __Pyx_c_prod(a, a);\n return __Pyx_c_prod(a, a);\n case 3:\n z = __Pyx_c_prod(a, a);\n return __Pyx_c_prod(z, a);\n case 4:\n z = __Pyx_c_prod(a, a);\n return __Pyx_c_prod(z, z);\n }\n }\n if (a.imag == 0) {\n if (a.real == 0) {\n return a;\n }\n r = a.real;\n theta = 0;\n } else {\n r = __Pyx_c_abs(a);\n theta = atan2(a.imag, a.real);\n }\n lnr = log(r);\n z_r = exp(lnr * b.real - theta * b.imag);\n z_theta = theta * b.real + lnr * b.imag;\n z.real = z_r * cos(z_theta);\n z.imag = z_r * sin(z_theta);\n return z;\n }\n #endif\n#endif\n\n/* CIntToPy */\n static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {\n const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0;\n const int is_unsigned = neg_one > const_zero;\n if (is_unsigned) {\n if (sizeof(enum NPY_TYPES) < sizeof(long)) {\n return PyInt_FromLong((long) value);\n } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {\n return PyLong_FromUnsignedLong((unsigned long) value);\n } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {\n return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);\n }\n } else {\n if (sizeof(enum NPY_TYPES) <= sizeof(long)) {\n return PyInt_FromLong((long) value);\n } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {\n return PyLong_FromLongLong((PY_LONG_LONG) value);\n }\n }\n {\n int one = 1; int little = (int)*(unsigned char *)&one;\n unsigned char *bytes = (unsigned char *)&value;\n return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),\n little, !is_unsigned);\n }\n}\n\n/* CIntFromPy */\n static CYTHON_INLINE npy_int32 __Pyx_PyInt_As_npy_int32(PyObject *x) {\n const npy_int32 neg_one = (npy_int32) -1, const_zero = (npy_int32) 0;\n const int is_unsigned = neg_one > const_zero;\n#if PY_MAJOR_VERSION < 3\n if (likely(PyInt_Check(x))) {\n if (sizeof(npy_int32) < sizeof(long)) {\n __PYX_VERIFY_RETURN_INT(npy_int32, long, PyInt_AS_LONG(x))\n } else {\n long val = PyInt_AS_LONG(x);\n if (is_unsigned && unlikely(val < 0)) {\n goto raise_neg_overflow;\n }\n return (npy_int32) val;\n }\n } else\n#endif\n if (likely(PyLong_Check(x))) {\n if (is_unsigned) {\n#if CYTHON_USE_PYLONG_INTERNALS\n const digit* digits = ((PyLongObject*)x)->ob_digit;\n switch (Py_SIZE(x)) {\n case 0: return (npy_int32) 0;\n case 1: __PYX_VERIFY_RETURN_INT(npy_int32, digit, digits[0])\n case 2:\n if (8 * sizeof(npy_int32) > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) >= 2 * PyLong_SHIFT) {\n return (npy_int32) (((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]));\n }\n }\n break;\n case 3:\n if (8 * sizeof(npy_int32) > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) >= 3 * PyLong_SHIFT) {\n return (npy_int32) (((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]));\n }\n }\n break;\n case 4:\n if (8 * sizeof(npy_int32) > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) >= 4 * PyLong_SHIFT) {\n return (npy_int32) (((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]));\n }\n }\n break;\n }\n#endif\n#if CYTHON_COMPILING_IN_CPYTHON\n if (unlikely(Py_SIZE(x) < 0)) {\n goto raise_neg_overflow;\n }\n#else\n {\n int result = PyObject_RichCompareBool(x, Py_False, Py_LT);\n if (unlikely(result < 0))\n return (npy_int32) -1;\n if (unlikely(result == 1))\n goto raise_neg_overflow;\n }\n#endif\n if (sizeof(npy_int32) <= sizeof(unsigned long)) {\n __PYX_VERIFY_RETURN_INT_EXC(npy_int32, unsigned long, PyLong_AsUnsignedLong(x))\n } else if (sizeof(npy_int32) <= sizeof(unsigned PY_LONG_LONG)) {\n __PYX_VERIFY_RETURN_INT_EXC(npy_int32, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))\n }\n } else {\n#if CYTHON_USE_PYLONG_INTERNALS\n const digit* digits = ((PyLongObject*)x)->ob_digit;\n switch (Py_SIZE(x)) {\n case 0: return (npy_int32) 0;\n case -1: __PYX_VERIFY_RETURN_INT(npy_int32, sdigit, (sdigit) (-(sdigit)digits[0]))\n case 1: __PYX_VERIFY_RETURN_INT(npy_int32, digit, +digits[0])\n case -2:\n if (8 * sizeof(npy_int32) - 1 > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) {\n return (npy_int32) (((npy_int32)-1)*(((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])));\n }\n }\n break;\n case 2:\n if (8 * sizeof(npy_int32) > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) {\n return (npy_int32) ((((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])));\n }\n }\n break;\n case -3:\n if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) {\n return (npy_int32) (((npy_int32)-1)*(((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])));\n }\n }\n break;\n case 3:\n if (8 * sizeof(npy_int32) > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) {\n return (npy_int32) ((((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])));\n }\n }\n break;\n case -4:\n if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) - 1 > 4 * PyLong_SHIFT) {\n return (npy_int32) (((npy_int32)-1)*(((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])));\n }\n }\n break;\n case 4:\n if (8 * sizeof(npy_int32) > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(npy_int32) - 1 > 4 * PyLong_SHIFT) {\n return (npy_int32) ((((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])));\n }\n }\n break;\n }\n#endif\n if (sizeof(npy_int32) <= sizeof(long)) {\n __PYX_VERIFY_RETURN_INT_EXC(npy_int32, long, PyLong_AsLong(x))\n } else if (sizeof(npy_int32) <= sizeof(PY_LONG_LONG)) {\n __PYX_VERIFY_RETURN_INT_EXC(npy_int32, PY_LONG_LONG, PyLong_AsLongLong(x))\n }\n }\n {\n#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)\n PyErr_SetString(PyExc_RuntimeError,\n \"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers\");\n#else\n npy_int32 val;\n PyObject *v = __Pyx_PyNumber_IntOrLong(x);\n #if PY_MAJOR_VERSION < 3\n if (likely(v) && !PyLong_Check(v)) {\n PyObject *tmp = v;\n v = PyNumber_Long(tmp);\n Py_DECREF(tmp);\n }\n #endif\n if (likely(v)) {\n int one = 1; int is_little = (int)*(unsigned char *)&one;\n unsigned char *bytes = (unsigned char *)&val;\n int ret = _PyLong_AsByteArray((PyLongObject *)v,\n bytes, sizeof(val),\n is_little, !is_unsigned);\n Py_DECREF(v);\n if (likely(!ret))\n return val;\n }\n#endif\n return (npy_int32) -1;\n }\n } else {\n npy_int32 val;\n PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);\n if (!tmp) return (npy_int32) -1;\n val = __Pyx_PyInt_As_npy_int32(tmp);\n Py_DECREF(tmp);\n return val;\n }\nraise_overflow:\n PyErr_SetString(PyExc_OverflowError,\n \"value too large to convert to npy_int32\");\n return (npy_int32) -1;\nraise_neg_overflow:\n PyErr_SetString(PyExc_OverflowError,\n \"can't convert negative value to npy_int32\");\n return (npy_int32) -1;\n}\n\n/* CIntFromPy */\n static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {\n const int neg_one = (int) -1, const_zero = (int) 0;\n const int is_unsigned = neg_one > const_zero;\n#if PY_MAJOR_VERSION < 3\n if (likely(PyInt_Check(x))) {\n if (sizeof(int) < sizeof(long)) {\n __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))\n } else {\n long val = PyInt_AS_LONG(x);\n if (is_unsigned && unlikely(val < 0)) {\n goto raise_neg_overflow;\n }\n return (int) val;\n }\n } else\n#endif\n if (likely(PyLong_Check(x))) {\n if (is_unsigned) {\n#if CYTHON_USE_PYLONG_INTERNALS\n const digit* digits = ((PyLongObject*)x)->ob_digit;\n switch (Py_SIZE(x)) {\n case 0: return (int) 0;\n case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])\n case 2:\n if (8 * sizeof(int) > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {\n return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));\n }\n }\n break;\n case 3:\n if (8 * sizeof(int) > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {\n return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));\n }\n }\n break;\n case 4:\n if (8 * sizeof(int) > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __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])))\n } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {\n return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));\n }\n }\n break;\n }\n#endif\n#if CYTHON_COMPILING_IN_CPYTHON\n if (unlikely(Py_SIZE(x) < 0)) {\n goto raise_neg_overflow;\n }\n#else\n {\n int result = PyObject_RichCompareBool(x, Py_False, Py_LT);\n if (unlikely(result < 0))\n return (int) -1;\n if (unlikely(result == 1))\n goto raise_neg_overflow;\n }\n#endif\n if (sizeof(int) <= sizeof(unsigned long)) {\n __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))\n } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {\n __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))\n }\n } else {\n#if CYTHON_USE_PYLONG_INTERNALS\n const digit* digits = ((PyLongObject*)x)->ob_digit;\n switch (Py_SIZE(x)) {\n case 0: return (int) 0;\n case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))\n case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0])\n case -2:\n if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {\n return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));\n }\n }\n break;\n case 2:\n if (8 * sizeof(int) > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {\n return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));\n }\n }\n break;\n case -3:\n if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {\n return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));\n }\n }\n break;\n case 3:\n if (8 * sizeof(int) > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {\n return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));\n }\n }\n break;\n case -4:\n if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __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])))\n } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {\n return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));\n }\n }\n break;\n case 4:\n if (8 * sizeof(int) > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __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])))\n } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {\n return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));\n }\n }\n break;\n }\n#endif\n if (sizeof(int) <= sizeof(long)) {\n __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))\n } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {\n __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))\n }\n }\n {\n#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)\n PyErr_SetString(PyExc_RuntimeError,\n \"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers\");\n#else\n int val;\n PyObject *v = __Pyx_PyNumber_IntOrLong(x);\n #if PY_MAJOR_VERSION < 3\n if (likely(v) && !PyLong_Check(v)) {\n PyObject *tmp = v;\n v = PyNumber_Long(tmp);\n Py_DECREF(tmp);\n }\n #endif\n if (likely(v)) {\n int one = 1; int is_little = (int)*(unsigned char *)&one;\n unsigned char *bytes = (unsigned char *)&val;\n int ret = _PyLong_AsByteArray((PyLongObject *)v,\n bytes, sizeof(val),\n is_little, !is_unsigned);\n Py_DECREF(v);\n if (likely(!ret))\n return val;\n }\n#endif\n return (int) -1;\n }\n } else {\n int val;\n PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);\n if (!tmp) return (int) -1;\n val = __Pyx_PyInt_As_int(tmp);\n Py_DECREF(tmp);\n return val;\n }\nraise_overflow:\n PyErr_SetString(PyExc_OverflowError,\n \"value too large to convert to int\");\n return (int) -1;\nraise_neg_overflow:\n PyErr_SetString(PyExc_OverflowError,\n \"can't convert negative value to int\");\n return (int) -1;\n}\n\n/* CIntToPy */\n static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {\n const long neg_one = (long) -1, const_zero = (long) 0;\n const int is_unsigned = neg_one > const_zero;\n if (is_unsigned) {\n if (sizeof(long) < sizeof(long)) {\n return PyInt_FromLong((long) value);\n } else if (sizeof(long) <= sizeof(unsigned long)) {\n return PyLong_FromUnsignedLong((unsigned long) value);\n } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {\n return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);\n }\n } else {\n if (sizeof(long) <= sizeof(long)) {\n return PyInt_FromLong((long) value);\n } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {\n return PyLong_FromLongLong((PY_LONG_LONG) value);\n }\n }\n {\n int one = 1; int little = (int)*(unsigned char *)&one;\n unsigned char *bytes = (unsigned char *)&value;\n return _PyLong_FromByteArray(bytes, sizeof(long),\n little, !is_unsigned);\n }\n}\n\n/* CIntFromPy */\n static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {\n const long neg_one = (long) -1, const_zero = (long) 0;\n const int is_unsigned = neg_one > const_zero;\n#if PY_MAJOR_VERSION < 3\n if (likely(PyInt_Check(x))) {\n if (sizeof(long) < sizeof(long)) {\n __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))\n } else {\n long val = PyInt_AS_LONG(x);\n if (is_unsigned && unlikely(val < 0)) {\n goto raise_neg_overflow;\n }\n return (long) val;\n }\n } else\n#endif\n if (likely(PyLong_Check(x))) {\n if (is_unsigned) {\n#if CYTHON_USE_PYLONG_INTERNALS\n const digit* digits = ((PyLongObject*)x)->ob_digit;\n switch (Py_SIZE(x)) {\n case 0: return (long) 0;\n case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])\n case 2:\n if (8 * sizeof(long) > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {\n return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));\n }\n }\n break;\n case 3:\n if (8 * sizeof(long) > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {\n return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));\n }\n }\n break;\n case 4:\n if (8 * sizeof(long) > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __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])))\n } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {\n return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));\n }\n }\n break;\n }\n#endif\n#if CYTHON_COMPILING_IN_CPYTHON\n if (unlikely(Py_SIZE(x) < 0)) {\n goto raise_neg_overflow;\n }\n#else\n {\n int result = PyObject_RichCompareBool(x, Py_False, Py_LT);\n if (unlikely(result < 0))\n return (long) -1;\n if (unlikely(result == 1))\n goto raise_neg_overflow;\n }\n#endif\n if (sizeof(long) <= sizeof(unsigned long)) {\n __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))\n } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {\n __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))\n }\n } else {\n#if CYTHON_USE_PYLONG_INTERNALS\n const digit* digits = ((PyLongObject*)x)->ob_digit;\n switch (Py_SIZE(x)) {\n case 0: return (long) 0;\n case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))\n case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0])\n case -2:\n if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {\n return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));\n }\n }\n break;\n case 2:\n if (8 * sizeof(long) > 1 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {\n return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));\n }\n }\n break;\n case -3:\n if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {\n return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));\n }\n }\n break;\n case 3:\n if (8 * sizeof(long) > 2 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {\n __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))\n } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {\n return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));\n }\n }\n break;\n case -4:\n if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __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])))\n } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {\n return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));\n }\n }\n break;\n case 4:\n if (8 * sizeof(long) > 3 * PyLong_SHIFT) {\n if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {\n __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])))\n } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {\n return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));\n }\n }\n break;\n }\n#endif\n if (sizeof(long) <= sizeof(long)) {\n __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))\n } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {\n __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))\n }\n }\n {\n#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)\n PyErr_SetString(PyExc_RuntimeError,\n \"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers\");\n#else\n long val;\n PyObject *v = __Pyx_PyNumber_IntOrLong(x);\n #if PY_MAJOR_VERSION < 3\n if (likely(v) && !PyLong_Check(v)) {\n PyObject *tmp = v;\n v = PyNumber_Long(tmp);\n Py_DECREF(tmp);\n }\n #endif\n if (likely(v)) {\n int one = 1; int is_little = (int)*(unsigned char *)&one;\n unsigned char *bytes = (unsigned char *)&val;\n int ret = _PyLong_AsByteArray((PyLongObject *)v,\n bytes, sizeof(val),\n is_little, !is_unsigned);\n Py_DECREF(v);\n if (likely(!ret))\n return val;\n }\n#endif\n return (long) -1;\n }\n } else {\n long val;\n PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);\n if (!tmp) return (long) -1;\n val = __Pyx_PyInt_As_long(tmp);\n Py_DECREF(tmp);\n return val;\n }\nraise_overflow:\n PyErr_SetString(PyExc_OverflowError,\n \"value too large to convert to long\");\n return (long) -1;\nraise_neg_overflow:\n PyErr_SetString(PyExc_OverflowError,\n \"can't convert negative value to long\");\n return (long) -1;\n}\n\n/* CheckBinaryVersion */\n static int __Pyx_check_binary_version(void) {\n char ctversion[4], rtversion[4];\n PyOS_snprintf(ctversion, 4, \"%d.%d\", PY_MAJOR_VERSION, PY_MINOR_VERSION);\n PyOS_snprintf(rtversion, 4, \"%s\", Py_GetVersion());\n if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {\n char message[200];\n PyOS_snprintf(message, sizeof(message),\n \"compiletime version %s of module '%.100s' \"\n \"does not match runtime version %s\",\n ctversion, __Pyx_MODULE_NAME, rtversion);\n return PyErr_WarnEx(NULL, message, 1);\n }\n return 0;\n}\n\n/* ModuleImport */\n #ifndef __PYX_HAVE_RT_ImportModule\n#define __PYX_HAVE_RT_ImportModule\nstatic PyObject *__Pyx_ImportModule(const char *name) {\n PyObject *py_name = 0;\n PyObject *py_module = 0;\n py_name = __Pyx_PyIdentifier_FromString(name);\n if (!py_name)\n goto bad;\n py_module = PyImport_Import(py_name);\n Py_DECREF(py_name);\n return py_module;\nbad:\n Py_XDECREF(py_name);\n return 0;\n}\n#endif\n\n/* TypeImport */\n #ifndef __PYX_HAVE_RT_ImportType\n#define __PYX_HAVE_RT_ImportType\nstatic PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,\n size_t size, int strict)\n{\n PyObject *py_module = 0;\n PyObject *result = 0;\n PyObject *py_name = 0;\n char warning[200];\n Py_ssize_t basicsize;\n#ifdef Py_LIMITED_API\n PyObject *py_basicsize;\n#endif\n py_module = __Pyx_ImportModule(module_name);\n if (!py_module)\n goto bad;\n py_name = __Pyx_PyIdentifier_FromString(class_name);\n if (!py_name)\n goto bad;\n result = PyObject_GetAttr(py_module, py_name);\n Py_DECREF(py_name);\n py_name = 0;\n Py_DECREF(py_module);\n py_module = 0;\n if (!result)\n goto bad;\n if (!PyType_Check(result)) {\n PyErr_Format(PyExc_TypeError,\n \"%.200s.%.200s is not a type object\",\n module_name, class_name);\n goto bad;\n }\n#ifndef Py_LIMITED_API\n basicsize = ((PyTypeObject *)result)->tp_basicsize;\n#else\n py_basicsize = PyObject_GetAttrString(result, \"__basicsize__\");\n if (!py_basicsize)\n goto bad;\n basicsize = PyLong_AsSsize_t(py_basicsize);\n Py_DECREF(py_basicsize);\n py_basicsize = 0;\n if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())\n goto bad;\n#endif\n if (!strict && (size_t)basicsize > size) {\n PyOS_snprintf(warning, sizeof(warning),\n \"%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd\",\n module_name, class_name, basicsize, size);\n if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;\n }\n else if ((size_t)basicsize != size) {\n PyErr_Format(PyExc_ValueError,\n \"%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd\",\n module_name, class_name, basicsize, size);\n goto bad;\n }\n return (PyTypeObject *)result;\nbad:\n Py_XDECREF(py_module);\n Py_XDECREF(result);\n return NULL;\n}\n#endif\n\n/* InitStrings */\n static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {\n while (t->p) {\n #if PY_MAJOR_VERSION < 3\n if (t->is_unicode) {\n *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);\n } else if (t->intern) {\n *t->p = PyString_InternFromString(t->s);\n } else {\n *t->p = PyString_FromStringAndSize(t->s, t->n - 1);\n }\n #else\n if (t->is_unicode | t->is_str) {\n if (t->intern) {\n *t->p = PyUnicode_InternFromString(t->s);\n } else if (t->encoding) {\n *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);\n } else {\n *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);\n }\n } else {\n *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);\n }\n #endif\n if (!*t->p)\n return -1;\n ++t;\n }\n return 0;\n}\n\nstatic CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {\n return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));\n}\nstatic CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {\n Py_ssize_t ignore;\n return __Pyx_PyObject_AsStringAndSize(o, &ignore);\n}\nstatic CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {\n#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)\n if (\n#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII\n __Pyx_sys_getdefaultencoding_not_ascii &&\n#endif\n PyUnicode_Check(o)) {\n#if PY_VERSION_HEX < 0x03030000\n char* defenc_c;\n PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);\n if (!defenc) return NULL;\n defenc_c = PyBytes_AS_STRING(defenc);\n#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII\n {\n char* end = defenc_c + PyBytes_GET_SIZE(defenc);\n char* c;\n for (c = defenc_c; c < end; c++) {\n if ((unsigned char) (*c) >= 128) {\n PyUnicode_AsASCIIString(o);\n return NULL;\n }\n }\n }\n#endif\n *length = PyBytes_GET_SIZE(defenc);\n return defenc_c;\n#else\n if (__Pyx_PyUnicode_READY(o) == -1) return NULL;\n#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII\n if (PyUnicode_IS_ASCII(o)) {\n *length = PyUnicode_GET_LENGTH(o);\n return PyUnicode_AsUTF8(o);\n } else {\n PyUnicode_AsASCIIString(o);\n return NULL;\n }\n#else\n return PyUnicode_AsUTF8AndSize(o, length);\n#endif\n#endif\n } else\n#endif\n#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))\n if (PyByteArray_Check(o)) {\n *length = PyByteArray_GET_SIZE(o);\n return PyByteArray_AS_STRING(o);\n } else\n#endif\n {\n char* result;\n int r = PyBytes_AsStringAndSize(o, &result, length);\n if (unlikely(r < 0)) {\n return NULL;\n } else {\n return result;\n }\n }\n}\nstatic CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {\n int is_true = x == Py_True;\n if (is_true | (x == Py_False) | (x == Py_None)) return is_true;\n else return PyObject_IsTrue(x);\n}\nstatic CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {\n PyNumberMethods *m;\n const char *name = NULL;\n PyObject *res = NULL;\n#if PY_MAJOR_VERSION < 3\n if (PyInt_Check(x) || PyLong_Check(x))\n#else\n if (PyLong_Check(x))\n#endif\n return __Pyx_NewRef(x);\n m = Py_TYPE(x)->tp_as_number;\n#if PY_MAJOR_VERSION < 3\n if (m && m->nb_int) {\n name = \"int\";\n res = PyNumber_Int(x);\n }\n else if (m && m->nb_long) {\n name = \"long\";\n res = PyNumber_Long(x);\n }\n#else\n if (m && m->nb_int) {\n name = \"int\";\n res = PyNumber_Long(x);\n }\n#endif\n if (res) {\n#if PY_MAJOR_VERSION < 3\n if (!PyInt_Check(res) && !PyLong_Check(res)) {\n#else\n if (!PyLong_Check(res)) {\n#endif\n PyErr_Format(PyExc_TypeError,\n \"__%.4s__ returned non-%.4s (type %.200s)\",\n name, name, Py_TYPE(res)->tp_name);\n Py_DECREF(res);\n return NULL;\n }\n }\n else if (!PyErr_Occurred()) {\n PyErr_SetString(PyExc_TypeError,\n \"an integer is required\");\n }\n return res;\n}\nstatic CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {\n Py_ssize_t ival;\n PyObject *x;\n#if PY_MAJOR_VERSION < 3\n if (likely(PyInt_CheckExact(b))) {\n if (sizeof(Py_ssize_t) >= sizeof(long))\n return PyInt_AS_LONG(b);\n else\n return PyInt_AsSsize_t(x);\n }\n#endif\n if (likely(PyLong_CheckExact(b))) {\n #if CYTHON_USE_PYLONG_INTERNALS\n const digit* digits = ((PyLongObject*)b)->ob_digit;\n const Py_ssize_t size = Py_SIZE(b);\n if (likely(__Pyx_sst_abs(size) <= 1)) {\n ival = likely(size) ? digits[0] : 0;\n if (size == -1) ival = -ival;\n return ival;\n } else {\n switch (size) {\n case 2:\n if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {\n return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));\n }\n break;\n case -2:\n if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {\n return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));\n }\n break;\n case 3:\n if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {\n return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));\n }\n break;\n case -3:\n if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {\n return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));\n }\n break;\n case 4:\n if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {\n return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));\n }\n break;\n case -4:\n if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {\n return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));\n }\n break;\n }\n }\n #endif\n return PyLong_AsSsize_t(b);\n }\n x = PyNumber_Index(b);\n if (!x) return -1;\n ival = PyInt_AsSsize_t(x);\n Py_DECREF(x);\n return ival;\n}\nstatic CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {\n return PyInt_FromSize_t(ival);\n}\n\n\n#endif /* Py_PYTHON_H */\n\n" }, { "path": "lib/nms/gpu_nms.hpp", "content": "void _nms(long* keep_out, int* num_out, const float* boxes_host, int boxes_num,\n int boxes_dim, float nms_overlap_thresh, int device_id);\n" }, { "path": "lib/nms/gpu_nms.pyx", "content": "# --------------------------------------------------------\n# Faster R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport numpy as np\ncimport numpy as np\n\nassert sizeof(int) == sizeof(np.int32_t)\n\ncdef extern from \"gpu_nms.hpp\":\n void _nms(np.int32_t*, int*, np.float32_t*, int, int, float, int)\n\ndef gpu_nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh,\n np.int32_t device_id=0):\n cdef int boxes_num = dets.shape[0]\n cdef int boxes_dim = dets.shape[1]\n cdef int num_out\n cdef np.ndarray[np.int32_t, ndim=1] \\\n keep = np.zeros(boxes_num, dtype=np.int32)\n cdef np.ndarray[np.float32_t, ndim=1] \\\n scores = dets[:, 4]\n #cdef np.ndarray[np.int_t, ndim=1] \\ // 20160601, by MrX\n # order = scores.argsort()[::-1]\n cdef np.ndarray[np.intp_t, ndim=1] \\\n order = scores.argsort()[::-1]\n cdef np.ndarray[np.float32_t, ndim=2] \\\n sorted_dets = dets[order, :]\n _nms(&keep[0], &num_out, &sorted_dets[0, 0], boxes_num, boxes_dim, thresh, device_id)\n keep = keep[:num_out]\n return list(order[keep])\n" }, { "path": "lib/nms/nms_kernel.cu", "content": "// ------------------------------------------------------------------\n// Faster R-CNN\n// Copyright (c) 2015 Microsoft\n// Licensed under The MIT License [see fast-rcnn/LICENSE for details]\n// Written by Shaoqing Ren\n// ------------------------------------------------------------------\n\n#include \"gpu_nms.hpp\"\n#include \n#include \n\n#define CUDA_CHECK(condition) \\\n /* Code block avoids redefinition of cudaError_t error */ \\\n do { \\\n cudaError_t error = condition; \\\n if (error != cudaSuccess) { \\\n std::cout << cudaGetErrorString(error) << std::endl; \\\n } \\\n } while (0)\n\n#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0))\nint const threadsPerBlock = sizeof(unsigned long long) * 8;\n\n__device__ inline float devIoU(float const * const a, float const * const b) {\n float left = max(a[0], b[0]), right = min(a[2], b[2]);\n float top = max(a[1], b[1]), bottom = min(a[3], b[3]);\n float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f);\n float interS = width * height;\n float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1);\n float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1);\n return interS / (Sa + Sb - interS);\n}\n\n__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh,\n const float *dev_boxes, unsigned long long *dev_mask) {\n const int row_start = blockIdx.y;\n const int col_start = blockIdx.x;\n\n // if (row_start > col_start) return;\n\n const int row_size =\n min(n_boxes - row_start * threadsPerBlock, threadsPerBlock);\n const int col_size =\n min(n_boxes - col_start * threadsPerBlock, threadsPerBlock);\n\n __shared__ float block_boxes[threadsPerBlock * 5];\n if (threadIdx.x < col_size) {\n block_boxes[threadIdx.x * 5 + 0] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0];\n block_boxes[threadIdx.x * 5 + 1] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1];\n block_boxes[threadIdx.x * 5 + 2] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2];\n block_boxes[threadIdx.x * 5 + 3] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3];\n block_boxes[threadIdx.x * 5 + 4] =\n dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4];\n }\n __syncthreads();\n\n if (threadIdx.x < row_size) {\n const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x;\n const float *cur_box = dev_boxes + cur_box_idx * 5;\n int i = 0;\n unsigned long long t = 0;\n int start = 0;\n if (row_start == col_start) {\n start = threadIdx.x + 1;\n }\n for (i = start; i < col_size; i++) {\n if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) {\n t |= 1ULL << i;\n }\n }\n const int col_blocks = DIVUP(n_boxes, threadsPerBlock);\n dev_mask[cur_box_idx * col_blocks + col_start] = t;\n }\n}\n\nvoid _set_device(int device_id) {\n int current_device;\n CUDA_CHECK(cudaGetDevice(¤t_device));\n if (current_device == device_id) {\n return;\n }\n // The call to cudaSetDevice must come before any calls to Get, which\n // may perform initialization using the GPU.\n CUDA_CHECK(cudaSetDevice(device_id));\n}\n\nvoid _nms(long* keep_out, int* num_out, const float* boxes_host, int boxes_num,\n int boxes_dim, float nms_overlap_thresh, int device_id) {\n _set_device(device_id);\n\n float* boxes_dev = NULL;\n unsigned long long* mask_dev = NULL;\n\n const int col_blocks = DIVUP(boxes_num, threadsPerBlock);\n\n CUDA_CHECK(cudaMalloc(&boxes_dev,\n boxes_num * boxes_dim * sizeof(float)));\n CUDA_CHECK(cudaMemcpy(boxes_dev,\n boxes_host,\n boxes_num * boxes_dim * sizeof(float),\n cudaMemcpyHostToDevice));\n\n CUDA_CHECK(cudaMalloc(&mask_dev,\n boxes_num * col_blocks * sizeof(unsigned long long)));\n\n dim3 blocks(DIVUP(boxes_num, threadsPerBlock),\n DIVUP(boxes_num, threadsPerBlock));\n dim3 threads(threadsPerBlock);\n nms_kernel<<>>(boxes_num,\n nms_overlap_thresh,\n boxes_dev,\n mask_dev);\n\n std::vector mask_host(boxes_num * col_blocks);\n CUDA_CHECK(cudaMemcpy(&mask_host[0],\n mask_dev,\n sizeof(unsigned long long) * boxes_num * col_blocks,\n cudaMemcpyDeviceToHost));\n\n std::vector remv(col_blocks);\n memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks);\n\n int num_to_keep = 0;\n for (int i = 0; i < boxes_num; i++) {\n int nblock = i / threadsPerBlock;\n int inblock = i % threadsPerBlock;\n\n if (!(remv[nblock] & (1ULL << inblock))) {\n keep_out[num_to_keep++] = i;\n unsigned long long *p = &mask_host[0] + i * col_blocks;\n for (int j = nblock; j < col_blocks; j++) {\n remv[j] |= p[j];\n }\n }\n }\n *num_out = num_to_keep;\n\n CUDA_CHECK(cudaFree(boxes_dev));\n CUDA_CHECK(cudaFree(mask_dev));\n}\n" }, { "path": "lib/nms/py_cpu_nms.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport numpy as np\n\ndef py_cpu_nms(dets, thresh):\n \"\"\"Pure Python NMS baseline.\"\"\"\n x1 = dets[:, 0]\n y1 = dets[:, 1]\n x2 = dets[:, 2]\n y2 = dets[:, 3]\n scores = dets[:, 4]\n\n areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n order = scores.argsort()[::-1]\n\n keep = []\n while order.size > 0:\n i = order[0]\n keep.append(i)\n xx1 = np.maximum(x1[i], x1[order[1:]])\n yy1 = np.maximum(y1[i], y1[order[1:]])\n xx2 = np.minimum(x2[i], x2[order[1:]])\n yy2 = np.minimum(y2[i], y2[order[1:]])\n\n w = np.maximum(0.0, xx2 - xx1 + 1)\n h = np.maximum(0.0, yy2 - yy1 + 1)\n inter = w * h\n ovr = inter / (areas[i] + areas[order[1:]] - inter)\n\n inds = np.where(ovr <= thresh)[0]\n order = order[inds + 1]\n\n return keep\n" }, { "path": "lib/pycocotools/UPSTREAM_REV", "content": "https://github.com/pdollar/coco/commit/3ac47c77ebd5a1ed4254a98b7fbf2ef4765a3574\n" }, { "path": "lib/pycocotools/__init__.py", "content": "__author__ = 'tylin'\n" }, { "path": "lib/pycocotools/_mask.pyx", "content": "# distutils: language = c\n# distutils: sources = ../MatlabAPI/private/maskApi.c\n\n#**************************************************************************\n# Microsoft COCO Toolbox. version 2.0\n# Data, paper, and tutorials available at: http://mscoco.org/\n# Code written by Piotr Dollar and Tsung-Yi Lin, 2015.\n# Licensed under the Simplified BSD License [see coco/license.txt]\n#**************************************************************************\n\n__author__ = 'tsungyi'\n\n# import both Python-level and C-level symbols of Numpy\n# the API uses Numpy to interface C and Python\nimport numpy as np\ncimport numpy as np\nfrom libc.stdlib cimport malloc, free\n\n# intialized Numpy. must do.\nnp.import_array()\n\n# import numpy C function\n# we use PyArray_ENABLEFLAGS to make Numpy ndarray responsible to memoery management\ncdef extern from \"numpy/arrayobject.h\":\n void PyArray_ENABLEFLAGS(np.ndarray arr, int flags)\n\n# Declare the prototype of the C functions in MaskApi.h\ncdef extern from \"maskApi.h\":\n ctypedef unsigned int uint\n ctypedef unsigned long siz\n ctypedef unsigned char byte\n ctypedef double* BB\n ctypedef struct RLE:\n siz h,\n siz w,\n siz m,\n uint* cnts,\n void rlesInit( RLE **R, siz n )\n void rleEncode( RLE *R, const byte *M, siz h, siz w, siz n )\n void rleDecode( const RLE *R, byte *mask, siz n )\n void rleMerge( const RLE *R, RLE *M, siz n, bint intersect )\n void rleArea( const RLE *R, siz n, uint *a )\n void rleIou( RLE *dt, RLE *gt, siz m, siz n, byte *iscrowd, double *o )\n void bbIou( BB dt, BB gt, siz m, siz n, byte *iscrowd, double *o )\n void rleToBbox( const RLE *R, BB bb, siz n )\n void rleFrBbox( RLE *R, const BB bb, siz h, siz w, siz n )\n void rleFrPoly( RLE *R, const double *xy, siz k, siz h, siz w )\n char* rleToString( const RLE *R )\n void rleFrString( RLE *R, char *s, siz h, siz w )\n\n# python class to wrap RLE array in C\n# the class handles the memory allocation and deallocation\ncdef class RLEs:\n cdef RLE *_R\n cdef siz _n\n\n def __cinit__(self, siz n =0):\n rlesInit(&self._R, n)\n self._n = n\n\n # free the RLE array here\n def __dealloc__(self):\n if self._R is not NULL:\n for i in range(self._n):\n free(self._R[i].cnts)\n free(self._R)\n def __getattr__(self, key):\n if key == 'n':\n return self._n\n raise AttributeError(key)\n\n# python class to wrap Mask array in C\n# the class handles the memory allocation and deallocation\ncdef class Masks:\n cdef byte *_mask\n cdef siz _h\n cdef siz _w\n cdef siz _n\n\n def __cinit__(self, h, w, n):\n self._mask = malloc(h*w*n* sizeof(byte))\n self._h = h\n self._w = w\n self._n = n\n # def __dealloc__(self):\n # the memory management of _mask has been passed to np.ndarray\n # it doesn't need to be freed here\n\n # called when passing into np.array() and return an np.ndarray in column-major order\n def __array__(self):\n cdef np.npy_intp shape[1]\n shape[0] = self._h*self._w*self._n\n # Create a 1D array, and reshape it to fortran/Matlab column-major array\n ndarray = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT8, self._mask).reshape((self._h, self._w, self._n), order='F')\n # The _mask allocated by Masks is now handled by ndarray\n PyArray_ENABLEFLAGS(ndarray, np.NPY_OWNDATA)\n return ndarray\n\n# internal conversion from Python RLEs object to compressed RLE format\ndef _toString(RLEs Rs):\n cdef siz n = Rs.n\n cdef bytes py_string\n cdef char* c_string\n objs = []\n for i in range(n):\n c_string = rleToString( &Rs._R[i] )\n py_string = c_string\n objs.append({\n 'size': [Rs._R[i].h, Rs._R[i].w],\n 'counts': py_string\n })\n free(c_string)\n return objs\n\n# internal conversion from compressed RLE format to Python RLEs object\ndef _frString(rleObjs):\n cdef siz n = len(rleObjs)\n Rs = RLEs(n)\n cdef bytes py_string\n cdef char* c_string\n for i, obj in enumerate(rleObjs):\n py_string = str(obj['counts'])\n c_string = py_string\n rleFrString( &Rs._R[i], c_string, obj['size'][0], obj['size'][1] )\n return Rs\n\n# encode mask to RLEs objects\n# list of RLE string can be generated by RLEs member function\ndef encode(np.ndarray[np.uint8_t, ndim=3, mode='fortran'] mask):\n h, w, n = mask.shape[0], mask.shape[1], mask.shape[2]\n cdef RLEs Rs = RLEs(n)\n rleEncode(Rs._R,mask.data,h,w,n)\n objs = _toString(Rs)\n return objs\n\n# decode mask from compressed list of RLE string or RLEs object\ndef decode(rleObjs):\n cdef RLEs Rs = _frString(rleObjs)\n h, w, n = Rs._R[0].h, Rs._R[0].w, Rs._n\n masks = Masks(h, w, n)\n rleDecode( Rs._R, masks._mask, n );\n return np.array(masks)\n\ndef merge(rleObjs, bint intersect=0):\n cdef RLEs Rs = _frString(rleObjs)\n cdef RLEs R = RLEs(1)\n rleMerge(Rs._R, R._R, Rs._n, intersect)\n obj = _toString(R)[0]\n return obj\n\ndef area(rleObjs):\n cdef RLEs Rs = _frString(rleObjs)\n cdef uint* _a = malloc(Rs._n* sizeof(uint))\n rleArea(Rs._R, Rs._n, _a)\n cdef np.npy_intp shape[1]\n shape[0] = Rs._n\n a = np.array((Rs._n, ), dtype=np.uint8)\n a = np.PyArray_SimpleNewFromData(1, shape, np.NPY_UINT32, _a)\n PyArray_ENABLEFLAGS(a, np.NPY_OWNDATA)\n return a\n\n# iou computation. support function overload (RLEs-RLEs and bbox-bbox).\ndef iou( dt, gt, pyiscrowd ):\n def _preproc(objs):\n if len(objs) == 0:\n return objs\n if type(objs) == np.ndarray:\n if len(objs.shape) == 1:\n objs = objs.reshape((objs[0], 1))\n # check if it's Nx4 bbox\n if not len(objs.shape) == 2 or not objs.shape[1] == 4:\n raise Exception('numpy ndarray input is only for *bounding boxes* and should have Nx4 dimension')\n objs = objs.astype(np.double)\n elif type(objs) == list:\n # check if list is in box format and convert it to np.ndarray\n isbox = np.all(np.array([(len(obj)==4) and ((type(obj)==list) or (type(obj)==np.ndarray)) for obj in objs]))\n isrle = np.all(np.array([type(obj) == dict for obj in objs]))\n if isbox:\n objs = np.array(objs, dtype=np.double)\n if len(objs.shape) == 1:\n objs = objs.reshape((1,objs.shape[0]))\n elif isrle:\n objs = _frString(objs)\n else:\n raise Exception('list input can be bounding box (Nx4) or RLEs ([RLE])')\n else:\n raise Exception('unrecognized type. The following type: RLEs (rle), np.ndarray (box), and list (box) are supported.')\n return objs\n def _rleIou(RLEs dt, RLEs gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):\n rleIou( dt._R, gt._R, m, n, iscrowd.data, _iou.data )\n def _bbIou(np.ndarray[np.double_t, ndim=2] dt, np.ndarray[np.double_t, ndim=2] gt, np.ndarray[np.uint8_t, ndim=1] iscrowd, siz m, siz n, np.ndarray[np.double_t, ndim=1] _iou):\n bbIou( dt.data, gt.data, m, n, iscrowd.data, _iou.data )\n def _len(obj):\n cdef siz N = 0\n if type(obj) == RLEs:\n N = obj.n\n elif len(obj)==0:\n pass\n elif type(obj) == np.ndarray:\n N = obj.shape[0]\n return N\n # convert iscrowd to numpy array\n cdef np.ndarray[np.uint8_t, ndim=1] iscrowd = np.array(pyiscrowd, dtype=np.uint8)\n # simple type checking\n cdef siz m, n\n dt = _preproc(dt)\n gt = _preproc(gt)\n m = _len(dt)\n n = _len(gt)\n if m == 0 or n == 0:\n return []\n if not type(dt) == type(gt):\n raise Exception('The dt and gt should have the same data type, either RLEs, list or np.ndarray')\n\n # define local variables\n cdef double* _iou = 0\n cdef np.npy_intp shape[1]\n # check type and assign iou function\n if type(dt) == RLEs:\n _iouFun = _rleIou\n elif type(dt) == np.ndarray:\n _iouFun = _bbIou\n else:\n raise Exception('input data type not allowed.')\n _iou = malloc(m*n* sizeof(double))\n iou = np.zeros((m*n, ), dtype=np.double)\n shape[0] = m*n\n iou = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _iou)\n PyArray_ENABLEFLAGS(iou, np.NPY_OWNDATA)\n _iouFun(dt, gt, iscrowd, m, n, iou)\n return iou.reshape((m,n), order='F')\n\ndef toBbox( rleObjs ):\n cdef RLEs Rs = _frString(rleObjs)\n cdef siz n = Rs.n\n cdef BB _bb = malloc(4*n* sizeof(double))\n rleToBbox( Rs._R, _bb, n )\n cdef np.npy_intp shape[1]\n shape[0] = 4*n\n bb = np.array((1,4*n), dtype=np.double)\n bb = np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE, _bb).reshape((n, 4))\n PyArray_ENABLEFLAGS(bb, np.NPY_OWNDATA)\n return bb\n\ndef frBbox(np.ndarray[np.double_t, ndim=2] bb, siz h, siz w ):\n cdef siz n = bb.shape[0]\n Rs = RLEs(n)\n rleFrBbox( Rs._R, bb.data, h, w, n )\n objs = _toString(Rs)\n return objs\n\ndef frPoly( poly, siz h, siz w ):\n cdef np.ndarray[np.double_t, ndim=1] np_poly\n n = len(poly)\n Rs = RLEs(n)\n for i, p in enumerate(poly):\n np_poly = np.array(p, dtype=np.double, order='F')\n rleFrPoly( &Rs._R[i], np_poly.data, len(np_poly)/2, h, w )\n objs = _toString(Rs)\n return objs\n\ndef frUncompressedRLE(ucRles, siz h, siz w):\n cdef np.ndarray[np.uint32_t, ndim=1] cnts\n cdef RLE R\n cdef uint *data\n n = len(ucRles)\n objs = []\n for i in range(n):\n Rs = RLEs(1)\n cnts = np.array(ucRles[i]['counts'], dtype=np.uint32)\n # time for malloc can be saved here but it's fine\n data = malloc(len(cnts)* sizeof(uint))\n for j in range(len(cnts)):\n data[j] = cnts[j]\n R = RLE(ucRles[i]['size'][0], ucRles[i]['size'][1], len(cnts), data)\n Rs._R[0] = R\n objs.append(_toString(Rs)[0])\n return objs\n\ndef frPyObjects(pyobj, siz h, w):\n if type(pyobj) == np.ndarray:\n objs = frBbox(pyobj, h, w )\n elif type(pyobj) == list and len(pyobj[0]) == 4:\n objs = frBbox(pyobj, h, w )\n elif type(pyobj) == list and len(pyobj[0]) > 4:\n objs = frPoly(pyobj, h, w )\n elif type(pyobj) == list and type(pyobj[0]) == dict:\n objs = frUncompressedRLE(pyobj, h, w)\n else:\n raise Exception('input type is not supported.')\n return objs\n" }, { "path": "lib/pycocotools/coco.py", "content": "__author__ = 'tylin'\n__version__ = '1.0.1'\n# Interface for accessing the Microsoft COCO dataset.\n\n# Microsoft COCO is a large image dataset designed for object detection,\n# segmentation, and caption generation. pycocotools is a Python API that\n# assists in loading, parsing and visualizing the annotations in COCO.\n# Please visit http://mscoco.org/ for more information on COCO, including\n# for the data, paper, and tutorials. The exact format of the annotations\n# is also described on the COCO website. For example usage of the pycocotools\n# please see pycocotools_demo.ipynb. In addition to this API, please download both\n# the COCO images and annotations in order to run the demo.\n\n# An alternative to using the API is to load the annotations directly\n# into Python dictionary\n# Using the API provides additional utility functions. Note that this API\n# supports both *instance* and *caption* annotations. In the case of\n# captions not all functions are defined (e.g. categories are undefined).\n\n# The following API functions are defined:\n# COCO - COCO api class that loads COCO annotation file and prepare data structures.\n# decodeMask - Decode binary mask M encoded via run-length encoding.\n# encodeMask - Encode binary mask M using run-length encoding.\n# getAnnIds - Get ann ids that satisfy given filter conditions.\n# getCatIds - Get cat ids that satisfy given filter conditions.\n# getImgIds - Get img ids that satisfy given filter conditions.\n# loadAnns - Load anns with the specified ids.\n# loadCats - Load cats with the specified ids.\n# loadImgs - Load imgs with the specified ids.\n# segToMask - Convert polygon segmentation to binary mask.\n# showAnns - Display the specified annotations.\n# loadRes - Load algorithm results and create API for accessing them.\n# download - Download COCO images from mscoco.org server.\n# Throughout the API \"ann\"=annotation, \"cat\"=category, and \"img\"=image.\n# Help on each functions can be accessed by: \"help COCO>function\".\n\n# See also COCO>decodeMask,\n# COCO>encodeMask, COCO>getAnnIds, COCO>getCatIds,\n# COCO>getImgIds, COCO>loadAnns, COCO>loadCats,\n# COCO>loadImgs, COCO>segToMask, COCO>showAnns\n\n# Microsoft COCO Toolbox. version 2.0\n# Data, paper, and tutorials available at: http://mscoco.org/\n# Code written by Piotr Dollar and Tsung-Yi Lin, 2014.\n# Licensed under the Simplified BSD License [see bsd.txt]\n\nimport json\nimport datetime\nimport time\nimport matplotlib.pyplot as plt\nfrom matplotlib.collections import PatchCollection\nfrom matplotlib.patches import Polygon\nimport numpy as np\nfrom skimage.draw import polygon\nimport urllib\nimport copy\nimport itertools\nimport mask\nimport os\n\nclass COCO:\n def __init__(self, annotation_file=None):\n \"\"\"\n Constructor of Microsoft COCO helper class for reading and visualizing annotations.\n :param annotation_file (str): location of annotation file\n :param image_folder (str): location to the folder that hosts images.\n :return:\n \"\"\"\n # load dataset\n self.dataset = {}\n self.anns = []\n self.imgToAnns = {}\n self.catToImgs = {}\n self.imgs = {}\n self.cats = {}\n if not annotation_file == None:\n print 'loading annotations into memory...'\n tic = time.time()\n dataset = json.load(open(annotation_file, 'r'))\n print 'Done (t=%0.2fs)'%(time.time()- tic)\n self.dataset = dataset\n self.createIndex()\n\n def createIndex(self):\n # create index\n print 'creating index...'\n anns = {}\n imgToAnns = {}\n catToImgs = {}\n cats = {}\n imgs = {}\n if 'annotations' in self.dataset:\n imgToAnns = {ann['image_id']: [] for ann in self.dataset['annotations']}\n anns = {ann['id']: [] for ann in self.dataset['annotations']}\n for ann in self.dataset['annotations']:\n imgToAnns[ann['image_id']] += [ann]\n anns[ann['id']] = ann\n\n if 'images' in self.dataset:\n imgs = {im['id']: {} for im in self.dataset['images']}\n for img in self.dataset['images']:\n imgs[img['id']] = img\n\n if 'categories' in self.dataset:\n cats = {cat['id']: [] for cat in self.dataset['categories']}\n for cat in self.dataset['categories']:\n cats[cat['id']] = cat\n catToImgs = {cat['id']: [] for cat in self.dataset['categories']}\n if 'annotations' in self.dataset:\n for ann in self.dataset['annotations']:\n catToImgs[ann['category_id']] += [ann['image_id']]\n\n print 'index created!'\n\n # create class members\n self.anns = anns\n self.imgToAnns = imgToAnns\n self.catToImgs = catToImgs\n self.imgs = imgs\n self.cats = cats\n\n def info(self):\n \"\"\"\n Print information about the annotation file.\n :return:\n \"\"\"\n for key, value in self.dataset['info'].items():\n print '%s: %s'%(key, value)\n\n def getAnnIds(self, imgIds=[], catIds=[], areaRng=[], iscrowd=None):\n \"\"\"\n Get ann ids that satisfy given filter conditions. default skips that filter\n :param imgIds (int array) : get anns for given imgs\n catIds (int array) : get anns for given cats\n areaRng (float array) : get anns for given area range (e.g. [0 inf])\n iscrowd (boolean) : get anns for given crowd label (False or True)\n :return: ids (int array) : integer array of ann ids\n \"\"\"\n imgIds = imgIds if type(imgIds) == list else [imgIds]\n catIds = catIds if type(catIds) == list else [catIds]\n\n if len(imgIds) == len(catIds) == len(areaRng) == 0:\n anns = self.dataset['annotations']\n else:\n if not len(imgIds) == 0:\n # this can be changed by defaultdict\n lists = [self.imgToAnns[imgId] for imgId in imgIds if imgId in self.imgToAnns]\n anns = list(itertools.chain.from_iterable(lists))\n else:\n anns = self.dataset['annotations']\n anns = anns if len(catIds) == 0 else [ann for ann in anns if ann['category_id'] in catIds]\n anns = anns if len(areaRng) == 0 else [ann for ann in anns if ann['area'] > areaRng[0] and ann['area'] < areaRng[1]]\n if not iscrowd == None:\n ids = [ann['id'] for ann in anns if ann['iscrowd'] == iscrowd]\n else:\n ids = [ann['id'] for ann in anns]\n return ids\n\n def getCatIds(self, catNms=[], supNms=[], catIds=[]):\n \"\"\"\n filtering parameters. default skips that filter.\n :param catNms (str array) : get cats for given cat names\n :param supNms (str array) : get cats for given supercategory names\n :param catIds (int array) : get cats for given cat ids\n :return: ids (int array) : integer array of cat ids\n \"\"\"\n catNms = catNms if type(catNms) == list else [catNms]\n supNms = supNms if type(supNms) == list else [supNms]\n catIds = catIds if type(catIds) == list else [catIds]\n\n if len(catNms) == len(supNms) == len(catIds) == 0:\n cats = self.dataset['categories']\n else:\n cats = self.dataset['categories']\n cats = cats if len(catNms) == 0 else [cat for cat in cats if cat['name'] in catNms]\n cats = cats if len(supNms) == 0 else [cat for cat in cats if cat['supercategory'] in supNms]\n cats = cats if len(catIds) == 0 else [cat for cat in cats if cat['id'] in catIds]\n ids = [cat['id'] for cat in cats]\n return ids\n\n def getImgIds(self, imgIds=[], catIds=[]):\n '''\n Get img ids that satisfy given filter conditions.\n :param imgIds (int array) : get imgs for given ids\n :param catIds (int array) : get imgs with all given cats\n :return: ids (int array) : integer array of img ids\n '''\n imgIds = imgIds if type(imgIds) == list else [imgIds]\n catIds = catIds if type(catIds) == list else [catIds]\n\n if len(imgIds) == len(catIds) == 0:\n ids = self.imgs.keys()\n else:\n ids = set(imgIds)\n for i, catId in enumerate(catIds):\n if i == 0 and len(ids) == 0:\n ids = set(self.catToImgs[catId])\n else:\n ids &= set(self.catToImgs[catId])\n return list(ids)\n\n def loadAnns(self, ids=[]):\n \"\"\"\n Load anns with the specified ids.\n :param ids (int array) : integer ids specifying anns\n :return: anns (object array) : loaded ann objects\n \"\"\"\n if type(ids) == list:\n return [self.anns[id] for id in ids]\n elif type(ids) == int:\n return [self.anns[ids]]\n\n def loadCats(self, ids=[]):\n \"\"\"\n Load cats with the specified ids.\n :param ids (int array) : integer ids specifying cats\n :return: cats (object array) : loaded cat objects\n \"\"\"\n if type(ids) == list:\n return [self.cats[id] for id in ids]\n elif type(ids) == int:\n return [self.cats[ids]]\n\n def loadImgs(self, ids=[]):\n \"\"\"\n Load anns with the specified ids.\n :param ids (int array) : integer ids specifying img\n :return: imgs (object array) : loaded img objects\n \"\"\"\n if type(ids) == list:\n return [self.imgs[id] for id in ids]\n elif type(ids) == int:\n return [self.imgs[ids]]\n\n def showAnns(self, anns):\n \"\"\"\n Display the specified annotations.\n :param anns (array of object): annotations to display\n :return: None\n \"\"\"\n if len(anns) == 0:\n return 0\n if 'segmentation' in anns[0]:\n datasetType = 'instances'\n elif 'caption' in anns[0]:\n datasetType = 'captions'\n if datasetType == 'instances':\n ax = plt.gca()\n polygons = []\n color = []\n for ann in anns:\n c = np.random.random((1, 3)).tolist()[0]\n if type(ann['segmentation']) == list:\n # polygon\n for seg in ann['segmentation']:\n poly = np.array(seg).reshape((len(seg)/2, 2))\n polygons.append(Polygon(poly, True,alpha=0.4))\n color.append(c)\n else:\n # mask\n t = self.imgs[ann['image_id']]\n if type(ann['segmentation']['counts']) == list:\n rle = mask.frPyObjects([ann['segmentation']], t['height'], t['width'])\n else:\n rle = [ann['segmentation']]\n m = mask.decode(rle)\n img = np.ones( (m.shape[0], m.shape[1], 3) )\n if ann['iscrowd'] == 1:\n color_mask = np.array([2.0,166.0,101.0])/255\n if ann['iscrowd'] == 0:\n color_mask = np.random.random((1, 3)).tolist()[0]\n for i in range(3):\n img[:,:,i] = color_mask[i]\n ax.imshow(np.dstack( (img, m*0.5) ))\n p = PatchCollection(polygons, facecolors=color, edgecolors=(0,0,0,1), linewidths=3, alpha=0.4)\n ax.add_collection(p)\n elif datasetType == 'captions':\n for ann in anns:\n print ann['caption']\n\n def loadRes(self, resFile):\n \"\"\"\n Load result file and return a result api object.\n :param resFile (str) : file name of result file\n :return: res (obj) : result api object\n \"\"\"\n res = COCO()\n res.dataset['images'] = [img for img in self.dataset['images']]\n # res.dataset['info'] = copy.deepcopy(self.dataset['info'])\n # res.dataset['licenses'] = copy.deepcopy(self.dataset['licenses'])\n\n print 'Loading and preparing results... '\n tic = time.time()\n anns = json.load(open(resFile))\n assert type(anns) == list, 'results in not an array of objects'\n annsImgIds = [ann['image_id'] for ann in anns]\n assert set(annsImgIds) == (set(annsImgIds) & set(self.getImgIds())), \\\n 'Results do not correspond to current coco set'\n if 'caption' in anns[0]:\n imgIds = set([img['id'] for img in res.dataset['images']]) & set([ann['image_id'] for ann in anns])\n res.dataset['images'] = [img for img in res.dataset['images'] if img['id'] in imgIds]\n for id, ann in enumerate(anns):\n ann['id'] = id+1\n elif 'bbox' in anns[0] and not anns[0]['bbox'] == []:\n res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])\n for id, ann in enumerate(anns):\n bb = ann['bbox']\n x1, x2, y1, y2 = [bb[0], bb[0]+bb[2], bb[1], bb[1]+bb[3]]\n if not 'segmentation' in ann:\n ann['segmentation'] = [[x1, y1, x1, y2, x2, y2, x2, y1]]\n ann['area'] = bb[2]*bb[3]\n ann['id'] = id+1\n ann['iscrowd'] = 0\n elif 'segmentation' in anns[0]:\n res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])\n for id, ann in enumerate(anns):\n # now only support compressed RLE format as segmentation results\n ann['area'] = mask.area([ann['segmentation']])[0]\n if not 'bbox' in ann:\n ann['bbox'] = mask.toBbox([ann['segmentation']])[0]\n ann['id'] = id+1\n ann['iscrowd'] = 0\n print 'DONE (t=%0.2fs)'%(time.time()- tic)\n\n res.dataset['annotations'] = anns\n res.createIndex()\n return res\n\n def download( self, tarDir = None, imgIds = [] ):\n '''\n Download COCO images from mscoco.org server.\n :param tarDir (str): COCO results directory name\n imgIds (list): images to be downloaded\n :return:\n '''\n if tarDir is None:\n print 'Please specify target directory'\n return -1\n if len(imgIds) == 0:\n imgs = self.imgs.values()\n else:\n imgs = self.loadImgs(imgIds)\n N = len(imgs)\n if not os.path.exists(tarDir):\n os.makedirs(tarDir)\n for i, img in enumerate(imgs):\n tic = time.time()\n fname = os.path.join(tarDir, img['file_name'])\n if not os.path.exists(fname):\n urllib.urlretrieve(img['coco_url'], fname)\n print 'downloaded %d/%d images (t=%.1fs)'%(i, N, time.time()- tic)\n" }, { "path": "lib/pycocotools/cocoeval.py", "content": "__author__ = 'tsungyi'\n\nimport numpy as np\nimport datetime\nimport time\nfrom collections import defaultdict\nimport mask\nimport copy\n\nclass COCOeval:\n # Interface for evaluating detection on the Microsoft COCO dataset.\n #\n # The usage for CocoEval is as follows:\n # cocoGt=..., cocoDt=... # load dataset and results\n # E = CocoEval(cocoGt,cocoDt); # initialize CocoEval object\n # E.params.recThrs = ...; # set parameters as desired\n # E.evaluate(); # run per image evaluation\n # E.accumulate(); # accumulate per image results\n # E.summarize(); # display summary metrics of results\n # For example usage see evalDemo.m and http://mscoco.org/.\n #\n # The evaluation parameters are as follows (defaults in brackets):\n # imgIds - [all] N img ids to use for evaluation\n # catIds - [all] K cat ids to use for evaluation\n # iouThrs - [.5:.05:.95] T=10 IoU thresholds for evaluation\n # recThrs - [0:.01:1] R=101 recall thresholds for evaluation\n # areaRng - [...] A=4 object area ranges for evaluation\n # maxDets - [1 10 100] M=3 thresholds on max detections per image\n # useSegm - [1] if true evaluate against ground-truth segments\n # useCats - [1] if true use category labels for evaluation # Note: if useSegm=0 the evaluation is run on bounding boxes.\n # Note: if useCats=0 category labels are ignored as in proposal scoring.\n # Note: multiple areaRngs [Ax2] and maxDets [Mx1] can be specified.\n #\n # evaluate(): evaluates detections on every image and every category and\n # concats the results into the \"evalImgs\" with fields:\n # dtIds - [1xD] id for each of the D detections (dt)\n # gtIds - [1xG] id for each of the G ground truths (gt)\n # dtMatches - [TxD] matching gt id at each IoU or 0\n # gtMatches - [TxG] matching dt id at each IoU or 0\n # dtScores - [1xD] confidence of each dt\n # gtIgnore - [1xG] ignore flag for each gt\n # dtIgnore - [TxD] ignore flag for each dt at each IoU\n #\n # accumulate(): accumulates the per-image, per-category evaluation\n # results in \"evalImgs\" into the dictionary \"eval\" with fields:\n # params - parameters used for evaluation\n # date - date evaluation was performed\n # counts - [T,R,K,A,M] parameter dimensions (see above)\n # precision - [TxRxKxAxM] precision for every evaluation setting\n # recall - [TxKxAxM] max recall for every evaluation setting\n # Note: precision and recall==-1 for settings with no gt objects.\n #\n # See also coco, mask, pycocoDemo, pycocoEvalDemo\n #\n # Microsoft COCO Toolbox. version 2.0\n # Data, paper, and tutorials available at: http://mscoco.org/\n # Code written by Piotr Dollar and Tsung-Yi Lin, 2015.\n # Licensed under the Simplified BSD License [see coco/license.txt]\n def __init__(self, cocoGt=None, cocoDt=None):\n '''\n Initialize CocoEval using coco APIs for gt and dt\n :param cocoGt: coco object with ground truth annotations\n :param cocoDt: coco object with detection results\n :return: None\n '''\n self.cocoGt = cocoGt # ground truth COCO API\n self.cocoDt = cocoDt # detections COCO API\n self.params = {} # evaluation parameters\n self.evalImgs = defaultdict(list) # per-image per-category evaluation results [KxAxI] elements\n self.eval = {} # accumulated evaluation results\n self._gts = defaultdict(list) # gt for evaluation\n self._dts = defaultdict(list) # dt for evaluation\n self.params = Params() # parameters\n self._paramsEval = {} # parameters for evaluation\n self.stats = [] # result summarization\n self.ious = {} # ious between all gts and dts\n if not cocoGt is None:\n self.params.imgIds = sorted(cocoGt.getImgIds())\n self.params.catIds = sorted(cocoGt.getCatIds())\n\n\n def _prepare(self):\n '''\n Prepare ._gts and ._dts for evaluation based on params\n :return: None\n '''\n #\n def _toMask(objs, coco):\n # modify segmentation by reference\n for obj in objs:\n t = coco.imgs[obj['image_id']]\n if type(obj['segmentation']) == list:\n if type(obj['segmentation'][0]) == dict:\n print 'debug'\n obj['segmentation'] = mask.frPyObjects(obj['segmentation'],t['height'],t['width'])\n if len(obj['segmentation']) == 1:\n obj['segmentation'] = obj['segmentation'][0]\n else:\n # an object can have multiple polygon regions\n # merge them into one RLE mask\n obj['segmentation'] = mask.merge(obj['segmentation'])\n elif type(obj['segmentation']) == dict and type(obj['segmentation']['counts']) == list:\n obj['segmentation'] = mask.frPyObjects([obj['segmentation']],t['height'],t['width'])[0]\n elif type(obj['segmentation']) == dict and \\\n type(obj['segmentation']['counts'] == unicode or type(obj['segmentation']['counts']) == str):\n pass\n else:\n raise Exception('segmentation format not supported.')\n p = self.params\n if p.useCats:\n gts=self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds))\n dts=self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds))\n else:\n gts=self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds))\n dts=self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds))\n\n if p.useSegm:\n _toMask(gts, self.cocoGt)\n _toMask(dts, self.cocoDt)\n self._gts = defaultdict(list) # gt for evaluation\n self._dts = defaultdict(list) # dt for evaluation\n for gt in gts:\n self._gts[gt['image_id'], gt['category_id']].append(gt)\n for dt in dts:\n self._dts[dt['image_id'], dt['category_id']].append(dt)\n self.evalImgs = defaultdict(list) # per-image per-category evaluation results\n self.eval = {} # accumulated evaluation results\n\n def evaluate(self):\n '''\n Run per image evaluation on given images and store results (a list of dict) in self.evalImgs\n :return: None\n '''\n tic = time.time()\n print 'Running per image evaluation... '\n p = self.params\n p.imgIds = list(np.unique(p.imgIds))\n if p.useCats:\n p.catIds = list(np.unique(p.catIds))\n p.maxDets = sorted(p.maxDets)\n self.params=p\n\n self._prepare()\n # loop through images, area range, max detection number\n catIds = p.catIds if p.useCats else [-1]\n\n computeIoU = self.computeIoU\n self.ious = {(imgId, catId): computeIoU(imgId, catId) \\\n for imgId in p.imgIds\n for catId in catIds}\n\n evaluateImg = self.evaluateImg\n maxDet = p.maxDets[-1]\n self.evalImgs = [evaluateImg(imgId, catId, areaRng, maxDet)\n for catId in catIds\n for areaRng in p.areaRng\n for imgId in p.imgIds\n ]\n self._paramsEval = copy.deepcopy(self.params)\n toc = time.time()\n print 'DONE (t=%0.2fs).'%(toc-tic)\n\n def computeIoU(self, imgId, catId):\n p = self.params\n if p.useCats:\n gt = self._gts[imgId,catId]\n dt = self._dts[imgId,catId]\n else:\n gt = [_ for cId in p.catIds for _ in self._gts[imgId,cId]]\n dt = [_ for cId in p.catIds for _ in self._dts[imgId,cId]]\n if len(gt) == 0 and len(dt) ==0:\n return []\n dt = sorted(dt, key=lambda x: -x['score'])\n if len(dt) > p.maxDets[-1]:\n dt=dt[0:p.maxDets[-1]]\n\n if p.useSegm:\n g = [g['segmentation'] for g in gt]\n d = [d['segmentation'] for d in dt]\n else:\n g = [g['bbox'] for g in gt]\n d = [d['bbox'] for d in dt]\n\n # compute iou between each dt and gt region\n iscrowd = [int(o['iscrowd']) for o in gt]\n ious = mask.iou(d,g,iscrowd)\n return ious\n\n def evaluateImg(self, imgId, catId, aRng, maxDet):\n '''\n perform evaluation for single category and image\n :return: dict (single image results)\n '''\n #\n p = self.params\n if p.useCats:\n gt = self._gts[imgId,catId]\n dt = self._dts[imgId,catId]\n else:\n gt = [_ for cId in p.catIds for _ in self._gts[imgId,cId]]\n dt = [_ for cId in p.catIds for _ in self._dts[imgId,cId]]\n if len(gt) == 0 and len(dt) ==0:\n return None\n\n for g in gt:\n if 'ignore' not in g:\n g['ignore'] = 0\n if g['iscrowd'] == 1 or g['ignore'] or (g['area']aRng[1]):\n g['_ignore'] = 1\n else:\n g['_ignore'] = 0\n\n # sort dt highest score first, sort gt ignore last\n # gt = sorted(gt, key=lambda x: x['_ignore'])\n gtind = [ind for (ind, g) in sorted(enumerate(gt), key=lambda (ind, g): g['_ignore']) ]\n\n gt = [gt[ind] for ind in gtind]\n dt = sorted(dt, key=lambda x: -x['score'])[0:maxDet]\n iscrowd = [int(o['iscrowd']) for o in gt]\n # load computed ious\n N_iou = len(self.ious[imgId, catId])\n ious = self.ious[imgId, catId][0:maxDet, np.array(gtind)] if N_iou >0 else self.ious[imgId, catId]\n\n T = len(p.iouThrs)\n G = len(gt)\n D = len(dt)\n gtm = np.zeros((T,G))\n dtm = np.zeros((T,D))\n gtIg = np.array([g['_ignore'] for g in gt])\n dtIg = np.zeros((T,D))\n if not len(ious)==0:\n for tind, t in enumerate(p.iouThrs):\n for dind, d in enumerate(dt):\n # information about best match so far (m=-1 -> unmatched)\n iou = min([t,1-1e-10])\n m = -1\n for gind, g in enumerate(gt):\n # if this gt already matched, and not a crowd, continue\n if gtm[tind,gind]>0 and not iscrowd[gind]:\n continue\n # if dt matched to reg gt, and on ignore gt, stop\n if m>-1 and gtIg[m]==0 and gtIg[gind]==1:\n break\n # continue to next gt unless better match made\n if ious[dind,gind] < iou:\n continue\n # match successful and best so far, store appropriately\n iou=ious[dind,gind]\n m=gind\n # if match made store id of match for both dt and gt\n if m ==-1:\n continue\n dtIg[tind,dind] = gtIg[m]\n dtm[tind,dind] = gt[m]['id']\n gtm[tind,m] = d['id']\n # set unmatched detections outside of area range to ignore\n a = np.array([d['area']aRng[1] for d in dt]).reshape((1, len(dt)))\n dtIg = np.logical_or(dtIg, np.logical_and(dtm==0, np.repeat(a,T,0)))\n # store results for given image and category\n return {\n 'image_id': imgId,\n 'category_id': catId,\n 'aRng': aRng,\n 'maxDet': maxDet,\n 'dtIds': [d['id'] for d in dt],\n 'gtIds': [g['id'] for g in gt],\n 'dtMatches': dtm,\n 'gtMatches': gtm,\n 'dtScores': [d['score'] for d in dt],\n 'gtIgnore': gtIg,\n 'dtIgnore': dtIg,\n }\n\n def accumulate(self, p = None):\n '''\n Accumulate per image evaluation results and store the result in self.eval\n :param p: input params for evaluation\n :return: None\n '''\n print 'Accumulating evaluation results... '\n tic = time.time()\n if not self.evalImgs:\n print 'Please run evaluate() first'\n # allows input customized parameters\n if p is None:\n p = self.params\n p.catIds = p.catIds if p.useCats == 1 else [-1]\n T = len(p.iouThrs)\n R = len(p.recThrs)\n K = len(p.catIds) if p.useCats else 1\n A = len(p.areaRng)\n M = len(p.maxDets)\n precision = -np.ones((T,R,K,A,M)) # -1 for the precision of absent categories\n recall = -np.ones((T,K,A,M))\n\n # create dictionary for future indexing\n _pe = self._paramsEval\n catIds = _pe.catIds if _pe.useCats else [-1]\n setK = set(catIds)\n setA = set(map(tuple, _pe.areaRng))\n setM = set(_pe.maxDets)\n setI = set(_pe.imgIds)\n # get inds to evaluate\n k_list = [n for n, k in enumerate(p.catIds) if k in setK]\n m_list = [m for n, m in enumerate(p.maxDets) if m in setM]\n a_list = [n for n, a in enumerate(map(lambda x: tuple(x), p.areaRng)) if a in setA]\n i_list = [n for n, i in enumerate(p.imgIds) if i in setI]\n # K0 = len(_pe.catIds)\n I0 = len(_pe.imgIds)\n A0 = len(_pe.areaRng)\n # retrieve E at each category, area range, and max number of detections\n for k, k0 in enumerate(k_list):\n Nk = k0*A0*I0\n for a, a0 in enumerate(a_list):\n Na = a0*I0\n for m, maxDet in enumerate(m_list):\n E = [self.evalImgs[Nk+Na+i] for i in i_list]\n E = filter(None, E)\n if len(E) == 0:\n continue\n dtScores = np.concatenate([e['dtScores'][0:maxDet] for e in E])\n\n # different sorting method generates slightly different results.\n # mergesort is used to be consistent as Matlab implementation.\n inds = np.argsort(-dtScores, kind='mergesort')\n\n dtm = np.concatenate([e['dtMatches'][:,0:maxDet] for e in E], axis=1)[:,inds]\n dtIg = np.concatenate([e['dtIgnore'][:,0:maxDet] for e in E], axis=1)[:,inds]\n gtIg = np.concatenate([e['gtIgnore'] for e in E])\n npig = len([ig for ig in gtIg if ig == 0])\n if npig == 0:\n continue\n tps = np.logical_and( dtm, np.logical_not(dtIg) )\n fps = np.logical_and(np.logical_not(dtm), np.logical_not(dtIg) )\n\n tp_sum = np.cumsum(tps, axis=1).astype(dtype=np.float)\n fp_sum = np.cumsum(fps, axis=1).astype(dtype=np.float)\n for t, (tp, fp) in enumerate(zip(tp_sum, fp_sum)):\n tp = np.array(tp)\n fp = np.array(fp)\n nd = len(tp)\n rc = tp / npig\n pr = tp / (fp+tp+np.spacing(1))\n q = np.zeros((R,))\n\n if nd:\n recall[t,k,a,m] = rc[-1]\n else:\n recall[t,k,a,m] = 0\n\n # numpy is slow without cython optimization for accessing elements\n # use python array gets significant speed improvement\n pr = pr.tolist(); q = q.tolist()\n\n for i in range(nd-1, 0, -1):\n if pr[i] > pr[i-1]:\n pr[i-1] = pr[i]\n\n inds = np.searchsorted(rc, p.recThrs)\n try:\n for ri, pi in enumerate(inds):\n q[ri] = pr[pi]\n except:\n pass\n precision[t,:,k,a,m] = np.array(q)\n self.eval = {\n 'params': p,\n 'counts': [T, R, K, A, M],\n 'date': datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"),\n 'precision': precision,\n 'recall': recall,\n }\n toc = time.time()\n print 'DONE (t=%0.2fs).'%( toc-tic )\n\n def summarize(self):\n '''\n Compute and display summary metrics for evaluation results.\n Note this functin can *only* be applied on the default parameter setting\n '''\n def _summarize( ap=1, iouThr=None, areaRng='all', maxDets=100 ):\n p = self.params\n iStr = ' {:<18} {} @[ IoU={:<9} | area={:>6} | maxDets={:>3} ] = {}'\n titleStr = 'Average Precision' if ap == 1 else 'Average Recall'\n typeStr = '(AP)' if ap==1 else '(AR)'\n iouStr = '%0.2f:%0.2f'%(p.iouThrs[0], p.iouThrs[-1]) if iouThr is None else '%0.2f'%(iouThr)\n areaStr = areaRng\n maxDetsStr = '%d'%(maxDets)\n\n aind = [i for i, aRng in enumerate(['all', 'small', 'medium', 'large']) if aRng == areaRng]\n mind = [i for i, mDet in enumerate([1, 10, 100]) if mDet == maxDets]\n if ap == 1:\n # dimension of precision: [TxRxKxAxM]\n s = self.eval['precision']\n # IoU\n if iouThr is not None:\n t = np.where(iouThr == p.iouThrs)[0]\n s = s[t]\n # areaRng\n s = s[:,:,:,aind,mind]\n else:\n # dimension of recall: [TxKxAxM]\n s = self.eval['recall']\n s = s[:,:,aind,mind]\n if len(s[s>-1])==0:\n mean_s = -1\n else:\n mean_s = np.mean(s[s>-1])\n print iStr.format(titleStr, typeStr, iouStr, areaStr, maxDetsStr, '%.3f'%(float(mean_s)))\n return mean_s\n\n if not self.eval:\n raise Exception('Please run accumulate() first')\n self.stats = np.zeros((12,))\n self.stats[0] = _summarize(1)\n self.stats[1] = _summarize(1,iouThr=.5)\n self.stats[2] = _summarize(1,iouThr=.75)\n self.stats[3] = _summarize(1,areaRng='small')\n self.stats[4] = _summarize(1,areaRng='medium')\n self.stats[5] = _summarize(1,areaRng='large')\n self.stats[6] = _summarize(0,maxDets=1)\n self.stats[7] = _summarize(0,maxDets=10)\n self.stats[8] = _summarize(0,maxDets=100)\n self.stats[9] = _summarize(0,areaRng='small')\n self.stats[10] = _summarize(0,areaRng='medium')\n self.stats[11] = _summarize(0,areaRng='large')\n\n def __str__(self):\n self.summarize()\n\nclass Params:\n '''\n Params for coco evaluation api\n '''\n def __init__(self):\n self.imgIds = []\n self.catIds = []\n # np.arange causes trouble. the data point on arange is slightly larger than the true value\n self.iouThrs = np.linspace(.5, 0.95, np.round((0.95-.5)/.05)+1, endpoint=True)\n self.recThrs = np.linspace(.0, 1.00, np.round((1.00-.0)/.01)+1, endpoint=True)\n self.maxDets = [1,10,100]\n self.areaRng = [ [0**2,1e5**2], [0**2, 32**2], [32**2, 96**2], [96**2, 1e5**2] ]\n self.useSegm = 0\n self.useCats = 1" }, { "path": "lib/pycocotools/license.txt", "content": "Copyright (c) 2014, Piotr Dollar and Tsung-Yi Lin\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met: \n\n1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer. \n2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution. \n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThe views and conclusions contained in the software and documentation are those\nof the authors and should not be interpreted as representing official policies, \neither expressed or implied, of the FreeBSD Project.\n" }, { "path": "lib/pycocotools/mask.py", "content": "__author__ = 'tsungyi'\n\nimport pycocotools._mask as _mask\n\n# Interface for manipulating masks stored in RLE format.\n#\n# RLE is a simple yet efficient format for storing binary masks. RLE\n# first divides a vector (or vectorized image) into a series of piecewise\n# constant regions and then for each piece simply stores the length of\n# that piece. For example, given M=[0 0 1 1 1 0 1] the RLE counts would\n# be [2 3 1 1], or for M=[1 1 1 1 1 1 0] the counts would be [0 6 1]\n# (note that the odd counts are always the numbers of zeros). Instead of\n# storing the counts directly, additional compression is achieved with a\n# variable bitrate representation based on a common scheme called LEB128.\n#\n# Compression is greatest given large piecewise constant regions.\n# Specifically, the size of the RLE is proportional to the number of\n# *boundaries* in M (or for an image the number of boundaries in the y\n# direction). Assuming fairly simple shapes, the RLE representation is\n# O(sqrt(n)) where n is number of pixels in the object. Hence space usage\n# is substantially lower, especially for large simple objects (large n).\n#\n# Many common operations on masks can be computed directly using the RLE\n# (without need for decoding). This includes computations such as area,\n# union, intersection, etc. All of these operations are linear in the\n# size of the RLE, in other words they are O(sqrt(n)) where n is the area\n# of the object. Computing these operations on the original mask is O(n).\n# Thus, using the RLE can result in substantial computational savings.\n#\n# The following API functions are defined:\n# encode - Encode binary masks using RLE.\n# decode - Decode binary masks encoded via RLE.\n# merge - Compute union or intersection of encoded masks.\n# iou - Compute intersection over union between masks.\n# area - Compute area of encoded masks.\n# toBbox - Get bounding boxes surrounding encoded masks.\n# frPyObjects - Convert polygon, bbox, and uncompressed RLE to encoded RLE mask.\n#\n# Usage:\n# Rs = encode( masks )\n# masks = decode( Rs )\n# R = merge( Rs, intersect=false )\n# o = iou( dt, gt, iscrowd )\n# a = area( Rs )\n# bbs = toBbox( Rs )\n# Rs = frPyObjects( [pyObjects], h, w )\n#\n# In the API the following formats are used:\n# Rs - [dict] Run-length encoding of binary masks\n# R - dict Run-length encoding of binary mask\n# masks - [hxwxn] Binary mask(s) (must have type np.ndarray(dtype=uint8) in column-major order)\n# iscrowd - [nx1] list of np.ndarray. 1 indicates corresponding gt image has crowd region to ignore\n# bbs - [nx4] Bounding box(es) stored as [x y w h]\n# poly - Polygon stored as [[x1 y1 x2 y2...],[x1 y1 ...],...] (2D list)\n# dt,gt - May be either bounding boxes or encoded masks\n# Both poly and bbs are 0-indexed (bbox=[0 0 1 1] encloses first pixel).\n#\n# Finally, a note about the intersection over union (iou) computation.\n# The standard iou of a ground truth (gt) and detected (dt) object is\n# iou(gt,dt) = area(intersect(gt,dt)) / area(union(gt,dt))\n# For \"crowd\" regions, we use a modified criteria. If a gt object is\n# marked as \"iscrowd\", we allow a dt to match any subregion of the gt.\n# Choosing gt' in the crowd gt that best matches the dt can be done using\n# gt'=intersect(dt,gt). Since by definition union(gt',dt)=dt, computing\n# iou(gt,dt,iscrowd) = iou(gt',dt) = area(intersect(gt,dt)) / area(dt)\n# For crowd gt regions we use this modified criteria above for the iou.\n#\n# To compile run \"python setup.py build_ext --inplace\"\n# Please do not contact us for help with compiling.\n#\n# Microsoft COCO Toolbox. version 2.0\n# Data, paper, and tutorials available at: http://mscoco.org/\n# Code written by Piotr Dollar and Tsung-Yi Lin, 2015.\n# Licensed under the Simplified BSD License [see coco/license.txt]\n\nencode = _mask.encode\ndecode = _mask.decode\niou = _mask.iou\nmerge = _mask.merge\narea = _mask.area\ntoBbox = _mask.toBbox\nfrPyObjects = _mask.frPyObjects" }, { "path": "lib/pycocotools/maskApi.c", "content": "/**************************************************************************\n* Microsoft COCO Toolbox. version 2.0\n* Data, paper, and tutorials available at: http://mscoco.org/\n* Code written by Piotr Dollar and Tsung-Yi Lin, 2015.\n* Licensed under the Simplified BSD License [see coco/license.txt]\n**************************************************************************/\n#include \"maskApi.h\"\n#include \n#include \n\nuint umin( uint a, uint b ) { return (ab) ? a : b; }\n\nvoid rleInit( RLE *R, siz h, siz w, siz m, uint *cnts ) {\n R->h=h; R->w=w; R->m=m; R->cnts=(m==0)?0:malloc(sizeof(uint)*m);\n if(cnts) for(siz j=0; jcnts[j]=cnts[j];\n}\n\nvoid rleFree( RLE *R ) {\n free(R->cnts); R->cnts=0;\n}\n\nvoid rlesInit( RLE **R, siz n ) {\n *R = (RLE*) malloc(sizeof(RLE)*n);\n for(siz i=0; i0 ) {\n c=umin(ca,cb); cc+=c; ct=0;\n ca-=c; if(!ca && a0) {\n crowd=iscrowd!=NULL && iscrowd[g];\n if(dt[d].h!=gt[g].h || dt[d].w!=gt[g].w) { o[g*m+d]=-1; continue; }\n siz ka, kb, a, b; uint c, ca, cb, ct, i, u; bool va, vb;\n ca=dt[d].cnts[0]; ka=dt[d].m; va=vb=0;\n cb=gt[g].cnts[0]; kb=gt[g].m; a=b=1; i=u=0; ct=1;\n while( ct>0 ) {\n c=umin(ca,cb); if(va||vb) { u+=c; if(va&&vb) i+=c; } ct=0;\n ca-=c; if(!ca && ad?1:c=dy && xs>xe) || (dxye);\n if(flip) { t=xs; xs=xe; xe=t; t=ys; ys=ye; ye=t; }\n s = dx>=dy ? (double)(ye-ys)/dx : (double)(xe-xs)/dy;\n if(dx>=dy) for( int d=0; d<=dx; d++ ) {\n t=flip?dx-d:d; u[m]=t+xs; v[m]=(int)(ys+s*t+.5); m++;\n } else for( int d=0; d<=dy; d++ ) {\n t=flip?dy-d:d; v[m]=t+ys; u[m]=(int)(xs+s*t+.5); m++;\n }\n }\n // get points along y-boundary and downsample\n free(x); free(y); k=m; m=0; double xd, yd;\n x=malloc(sizeof(int)*k); y=malloc(sizeof(int)*k);\n for( j=1; jw-1 ) continue;\n yd=(double)(v[j]h) yd=h; yd=ceil(yd);\n x[m]=(int) xd; y[m]=(int) yd; m++;\n }\n // compute rle encoding given y-boundary points\n k=m; a=malloc(sizeof(uint)*(k+1));\n for( j=0; j0) b[m++]=a[j++]; else {\n j++; if(jm, p=0; long x; bool more;\n char *s=malloc(sizeof(char)*m*6);\n for( i=0; icnts[i]; if(i>2) x-=(long) R->cnts[i-2]; more=1;\n while( more ) {\n char c=x & 0x1f; x >>= 5; more=(c & 0x10) ? x!=-1 : x!=0;\n if(more) c |= 0x20; c+=48; s[p++]=c;\n }\n }\n s[p]=0; return s;\n}\n\nvoid rleFrString( RLE *R, char *s, siz h, siz w ) {\n siz m=0, p=0, k; long x; bool more; uint *cnts;\n while( s[m] ) m++; cnts=malloc(sizeof(uint)*m); m=0;\n while( s[p] ) {\n x=0; k=0; more=1;\n while( more ) {\n char c=s[p]-48; x |= (c & 0x1f) << 5*k;\n more = c & 0x20; p++; k++;\n if(!more && (c & 0x10)) x |= -1 << 5*k;\n }\n if(m>2) x+=(long) cnts[m-2]; cnts[m++]=(uint) x;\n }\n rleInit(R,h,w,m,cnts); free(cnts);\n}\n" }, { "path": "lib/pycocotools/maskApi.h", "content": "/**************************************************************************\n* Microsoft COCO Toolbox. version 2.0\n* Data, paper, and tutorials available at: http://mscoco.org/\n* Code written by Piotr Dollar and Tsung-Yi Lin, 2015.\n* Licensed under the Simplified BSD License [see coco/license.txt]\n**************************************************************************/\n#pragma once\n#include \n\ntypedef unsigned int uint;\ntypedef unsigned long siz;\ntypedef unsigned char byte;\ntypedef double* BB;\ntypedef struct { siz h, w, m; uint *cnts; } RLE;\n\n// Initialize/destroy RLE.\nvoid rleInit( RLE *R, siz h, siz w, siz m, uint *cnts );\nvoid rleFree( RLE *R );\n\n// Initialize/destroy RLE array.\nvoid rlesInit( RLE **R, siz n );\nvoid rlesFree( RLE **R, siz n );\n\n// Encode binary masks using RLE.\nvoid rleEncode( RLE *R, const byte *mask, siz h, siz w, siz n );\n\n// Decode binary masks encoded via RLE.\nvoid rleDecode( const RLE *R, byte *mask, siz n );\n\n// Compute union or intersection of encoded masks.\nvoid rleMerge( const RLE *R, RLE *M, siz n, bool intersect );\n\n// Compute area of encoded masks.\nvoid rleArea( const RLE *R, siz n, uint *a );\n\n// Compute intersection over union between masks.\nvoid rleIou( RLE *dt, RLE *gt, siz m, siz n, byte *iscrowd, double *o );\n\n// Compute intersection over union between bounding boxes.\nvoid bbIou( BB dt, BB gt, siz m, siz n, byte *iscrowd, double *o );\n\n// Get bounding boxes surrounding encoded masks.\nvoid rleToBbox( const RLE *R, BB bb, siz n );\n\n// Convert bounding boxes to encoded masks.\nvoid rleFrBbox( RLE *R, const BB bb, siz h, siz w, siz n );\n\n// Convert polygon to encoded mask.\nvoid rleFrPoly( RLE *R, const double *xy, siz k, siz h, siz w );\n\n// Get compressed string representation of encoded mask.\nchar* rleToString( const RLE *R );\n\n// Convert from compressed string representation of encoded mask.\nvoid rleFrString( RLE *R, char *s, siz h, siz w );\n" }, { "path": "lib/roi_data_layer/__init__.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n" }, { "path": "lib/roi_data_layer/layer.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"The data layer used during training to train a Fast R-CNN network.\n\nRoIDataLayer implements a Caffe Python layer.\n\"\"\"\n\nimport caffe\nfrom fast_rcnn.config import cfg\nfrom roi_data_layer.minibatch import get_minibatch\nimport numpy as np\nimport yaml\nfrom multiprocessing import Process, Queue\n\nclass RoIDataLayer(caffe.Layer):\n \"\"\"Fast R-CNN data layer used for training.\"\"\"\n\n def _shuffle_roidb_inds(self):\n \"\"\"Randomly permute the training roidb.\"\"\"\n if cfg.TRAIN.ASPECT_GROUPING:\n widths = np.array([r['width'] for r in self._roidb])\n heights = np.array([r['height'] for r in self._roidb])\n horz = (widths >= heights)\n vert = np.logical_not(horz)\n horz_inds = np.where(horz)[0]\n vert_inds = np.where(vert)[0]\n inds = np.hstack((\n np.random.permutation(horz_inds),\n np.random.permutation(vert_inds)))\n inds = np.reshape(inds, (-1, 2))\n row_perm = np.random.permutation(np.arange(inds.shape[0]))\n inds = np.reshape(inds[row_perm, :], (-1,))\n self._perm = inds\n else:\n self._perm = np.random.permutation(np.arange(len(self._roidb)))\n self._cur = 0\n\n def _get_next_minibatch_inds(self):\n \"\"\"Return the roidb indices for the next minibatch.\"\"\"\n if self._cur + cfg.TRAIN.IMS_PER_BATCH >= len(self._roidb):\n self._shuffle_roidb_inds()\n\n db_inds = self._perm[self._cur:self._cur + cfg.TRAIN.IMS_PER_BATCH]\n self._cur += cfg.TRAIN.IMS_PER_BATCH\n return db_inds\n\n def _get_next_minibatch(self):\n \"\"\"Return the blobs to be used for the next minibatch.\n\n If cfg.TRAIN.USE_PREFETCH is True, then blobs will be computed in a\n separate process and made available through self._blob_queue.\n \"\"\"\n if cfg.TRAIN.USE_PREFETCH:\n return self._blob_queue.get()\n else:\n db_inds = self._get_next_minibatch_inds()\n minibatch_db = [self._roidb[i] for i in db_inds]\n return get_minibatch(minibatch_db, self._num_classes)\n\n def set_roidb(self, roidb):\n \"\"\"Set the roidb to be used by this layer during training.\"\"\"\n self._roidb = roidb\n self._shuffle_roidb_inds()\n if cfg.TRAIN.USE_PREFETCH:\n self._blob_queue = Queue(10)\n self._prefetch_process = BlobFetcher(self._blob_queue,\n self._roidb,\n self._num_classes)\n self._prefetch_process.start()\n # Terminate the child process when the parent exists\n def cleanup():\n print 'Terminating BlobFetcher'\n self._prefetch_process.terminate()\n self._prefetch_process.join()\n import atexit\n atexit.register(cleanup)\n\n def setup(self, bottom, top):\n \"\"\"Setup the RoIDataLayer.\"\"\"\n\n # parse the layer parameter string, which must be valid YAML\n layer_params = yaml.load(self.param_str_)\n\n self._num_classes = layer_params['num_classes']\n\n self._name_to_top_map = {}\n\n # data blob: holds a batch of N images, each with 3 channels\n idx = 0\n top[idx].reshape(cfg.TRAIN.IMS_PER_BATCH, 3,\n max(cfg.TRAIN.SCALES), cfg.TRAIN.MAX_SIZE)\n self._name_to_top_map['data'] = idx\n idx += 1\n\n if cfg.TRAIN.HAS_RPN:\n top[idx].reshape(1, 3)\n self._name_to_top_map['im_info'] = idx\n idx += 1\n\n top[idx].reshape(1, 4)\n self._name_to_top_map['gt_boxes'] = idx\n idx += 1\n else: # not using RPN\n # rois blob: holds R regions of interest, each is a 5-tuple\n # (n, x1, y1, x2, y2) specifying an image batch index n and a\n # rectangle (x1, y1, x2, y2)\n top[idx].reshape(1, 5)\n self._name_to_top_map['rois'] = idx\n idx += 1\n\n # labels blob: R categorical labels in [0, ..., K] for K foreground\n # classes plus background\n top[idx].reshape(1)\n self._name_to_top_map['labels'] = idx\n idx += 1\n\n if cfg.TRAIN.BBOX_REG:\n # bbox_targets blob: R bounding-box regression targets with 4\n # targets per class\n top[idx].reshape(1, self._num_classes * 4)\n self._name_to_top_map['bbox_targets'] = idx\n idx += 1\n\n # bbox_inside_weights blob: At most 4 targets per roi are active;\n # thisbinary vector sepcifies the subset of active targets\n top[idx].reshape(1, self._num_classes * 4)\n self._name_to_top_map['bbox_inside_weights'] = idx\n idx += 1\n\n top[idx].reshape(1, self._num_classes * 4)\n self._name_to_top_map['bbox_outside_weights'] = idx\n idx += 1\n\n print 'RoiDataLayer: name_to_top:', self._name_to_top_map\n assert len(top) == len(self._name_to_top_map)\n\n def forward(self, bottom, top):\n \"\"\"Get blobs and copy them into this layer's top blob vector.\"\"\"\n blobs = self._get_next_minibatch()\n\n for blob_name, blob in blobs.iteritems():\n top_ind = self._name_to_top_map[blob_name]\n # Reshape net's input blobs\n top[top_ind].reshape(*(blob.shape))\n # Copy data into net's input blobs\n top[top_ind].data[...] = blob.astype(np.float32, copy=False)\n\n def backward(self, top, propagate_down, bottom):\n \"\"\"This layer does not propagate gradients.\"\"\"\n pass\n\n def reshape(self, bottom, top):\n \"\"\"Reshaping happens during the call to forward.\"\"\"\n pass\n\nclass BlobFetcher(Process):\n \"\"\"Experimental class for prefetching blobs in a separate process.\"\"\"\n def __init__(self, queue, roidb, num_classes):\n super(BlobFetcher, self).__init__()\n self._queue = queue\n self._roidb = roidb\n self._num_classes = num_classes\n self._perm = None\n self._cur = 0\n self._shuffle_roidb_inds()\n # fix the random seed for reproducibility\n np.random.seed(cfg.RNG_SEED)\n\n def _shuffle_roidb_inds(self):\n \"\"\"Randomly permute the training roidb.\"\"\"\n # TODO(rbg): remove duplicated code\n self._perm = np.random.permutation(np.arange(len(self._roidb)))\n self._cur = 0\n\n def _get_next_minibatch_inds(self):\n \"\"\"Return the roidb indices for the next minibatch.\"\"\"\n # TODO(rbg): remove duplicated code\n if self._cur + cfg.TRAIN.IMS_PER_BATCH >= len(self._roidb):\n self._shuffle_roidb_inds()\n\n db_inds = self._perm[self._cur:self._cur + cfg.TRAIN.IMS_PER_BATCH]\n self._cur += cfg.TRAIN.IMS_PER_BATCH\n return db_inds\n\n def run(self):\n print 'BlobFetcher started'\n while True:\n db_inds = self._get_next_minibatch_inds()\n minibatch_db = [self._roidb[i] for i in db_inds]\n blobs = get_minibatch(minibatch_db, self._num_classes)\n self._queue.put(blobs)\n" }, { "path": "lib/roi_data_layer/minibatch.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Compute minibatch blobs for training a Fast R-CNN network.\"\"\"\n\nimport numpy as np\nimport numpy.random as npr\nimport cv2\nfrom fast_rcnn.config import cfg\nfrom utils.blob import prep_im_for_blob, im_list_to_blob\n\ndef get_minibatch(roidb, num_classes):\n \"\"\"Given a roidb, construct a minibatch sampled from it.\"\"\"\n num_images = len(roidb)\n # Sample random scales to use for each image in this batch\n random_scale_inds = npr.randint(0, high=len(cfg.TRAIN.SCALES),\n size=num_images)\n assert(cfg.TRAIN.BATCH_SIZE % num_images == 0), \\\n 'num_images ({}) must divide BATCH_SIZE ({})'. \\\n format(num_images, cfg.TRAIN.BATCH_SIZE)\n rois_per_image = cfg.TRAIN.BATCH_SIZE / num_images\n fg_rois_per_image = np.round(cfg.TRAIN.FG_FRACTION * rois_per_image)\n\n # Get the input image blob, formatted for caffe\n im_blob, im_scales = _get_image_blob(roidb, random_scale_inds)\n\n blobs = {'data': im_blob}\n\n if cfg.TRAIN.HAS_RPN:\n assert len(im_scales) == 1, \"Single batch only\"\n assert len(roidb) == 1, \"Single batch only\"\n # gt boxes: (x1, y1, x2, y2, cls)\n gt_inds = np.where(roidb[0]['gt_classes'] != 0)[0]\n gt_boxes = np.empty((len(gt_inds), 5), dtype=np.float32)\n gt_boxes[:, 0:4] = roidb[0]['boxes'][gt_inds, :] * im_scales[0]\n gt_boxes[:, 4] = roidb[0]['gt_classes'][gt_inds]\n blobs['gt_boxes'] = gt_boxes\n blobs['im_info'] = np.array(\n [[im_blob.shape[2], im_blob.shape[3], im_scales[0]]],\n dtype=np.float32)\n else: # not using RPN\n # Now, build the region of interest and label blobs\n rois_blob = np.zeros((0, 5), dtype=np.float32)\n labels_blob = np.zeros((0), dtype=np.float32)\n bbox_targets_blob = np.zeros((0, 4 * num_classes), dtype=np.float32)\n bbox_inside_blob = np.zeros(bbox_targets_blob.shape, dtype=np.float32)\n # all_overlaps = []\n for im_i in xrange(num_images):\n labels, overlaps, im_rois, bbox_targets, bbox_inside_weights \\\n = _sample_rois(roidb[im_i], fg_rois_per_image, rois_per_image,\n num_classes)\n\n # Add to RoIs blob\n rois = _project_im_rois(im_rois, im_scales[im_i])\n batch_ind = im_i * np.ones((rois.shape[0], 1))\n rois_blob_this_image = np.hstack((batch_ind, rois))\n rois_blob = np.vstack((rois_blob, rois_blob_this_image))\n\n # Add to labels, bbox targets, and bbox loss blobs\n labels_blob = np.hstack((labels_blob, labels))\n bbox_targets_blob = np.vstack((bbox_targets_blob, bbox_targets))\n bbox_inside_blob = np.vstack((bbox_inside_blob, bbox_inside_weights))\n # all_overlaps = np.hstack((all_overlaps, overlaps))\n\n # For debug visualizations\n # _vis_minibatch(im_blob, rois_blob, labels_blob, all_overlaps)\n\n blobs['rois'] = rois_blob\n blobs['labels'] = labels_blob\n\n if cfg.TRAIN.BBOX_REG:\n blobs['bbox_targets'] = bbox_targets_blob\n blobs['bbox_inside_weights'] = bbox_inside_blob\n blobs['bbox_outside_weights'] = \\\n np.array(bbox_inside_blob > 0).astype(np.float32)\n\n return blobs\n\ndef _sample_rois(roidb, fg_rois_per_image, rois_per_image, num_classes):\n \"\"\"Generate a random sample of RoIs comprising foreground and background\n examples.\n \"\"\"\n # label = class RoI has max overlap with\n labels = roidb['max_classes']\n overlaps = roidb['max_overlaps']\n rois = roidb['boxes']\n\n # Select foreground RoIs as those with >= FG_THRESH overlap\n fg_inds = np.where(overlaps >= cfg.TRAIN.FG_THRESH)[0]\n # Guard against the case when an image has fewer than fg_rois_per_image\n # foreground RoIs\n fg_rois_per_this_image = np.minimum(fg_rois_per_image, fg_inds.size)\n # Sample foreground regions without replacement\n if fg_inds.size > 0:\n fg_inds = npr.choice(\n fg_inds, size=fg_rois_per_this_image, replace=False)\n\n # Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)\n bg_inds = np.where((overlaps < cfg.TRAIN.BG_THRESH_HI) &\n (overlaps >= cfg.TRAIN.BG_THRESH_LO))[0]\n # Compute number of background RoIs to take from this image (guarding\n # against there being fewer than desired)\n bg_rois_per_this_image = rois_per_image - fg_rois_per_this_image\n bg_rois_per_this_image = np.minimum(bg_rois_per_this_image,\n bg_inds.size)\n # Sample foreground regions without replacement\n if bg_inds.size > 0:\n bg_inds = npr.choice(\n bg_inds, size=bg_rois_per_this_image, replace=False)\n\n # The indices that we're selecting (both fg and bg)\n keep_inds = np.append(fg_inds, bg_inds)\n # Select sampled values from various arrays:\n labels = labels[keep_inds]\n # Clamp labels for the background RoIs to 0\n labels[fg_rois_per_this_image:] = 0\n overlaps = overlaps[keep_inds]\n rois = rois[keep_inds]\n\n bbox_targets, bbox_inside_weights = _get_bbox_regression_labels(\n roidb['bbox_targets'][keep_inds, :], num_classes)\n\n return labels, overlaps, rois, bbox_targets, bbox_inside_weights\n\ndef _get_image_blob(roidb, scale_inds):\n \"\"\"Builds an input blob from the images in the roidb at the specified\n scales.\n \"\"\"\n num_images = len(roidb)\n processed_ims = []\n im_scales = []\n for i in xrange(num_images):\n im = cv2.imread(roidb[i]['image'])\n if roidb[i]['flipped']:\n im = im[:, ::-1, :]\n target_size = cfg.TRAIN.SCALES[scale_inds[i]]\n im, im_scale = prep_im_for_blob(im, cfg.PIXEL_MEANS, target_size,\n cfg.TRAIN.MAX_SIZE)\n im_scales.append(im_scale)\n processed_ims.append(im)\n\n # Create a blob to hold the input images\n blob = im_list_to_blob(processed_ims)\n\n return blob, im_scales\n\ndef _project_im_rois(im_rois, im_scale_factor):\n \"\"\"Project image RoIs into the rescaled training image.\"\"\"\n rois = im_rois * im_scale_factor\n return rois\n\ndef _get_bbox_regression_labels(bbox_target_data, num_classes):\n \"\"\"Bounding-box regression targets are stored in a compact form in the\n roidb.\n\n This function expands those targets into the 4-of-4*K representation used\n by the network (i.e. only one class has non-zero targets). The loss weights\n are similarly expanded.\n\n Returns:\n bbox_target_data (ndarray): N x 4K blob of regression targets\n bbox_inside_weights (ndarray): N x 4K blob of loss weights\n \"\"\"\n clss = bbox_target_data[:, 0]\n bbox_targets = np.zeros((clss.size, 4 * num_classes), dtype=np.float32)\n bbox_inside_weights = np.zeros(bbox_targets.shape, dtype=np.float32)\n inds = np.where(clss > 0)[0]\n for ind in inds:\n cls = clss[ind]\n start = 4 * cls\n end = start + 4\n bbox_targets[ind, start:end] = bbox_target_data[ind, 1:]\n bbox_inside_weights[ind, start:end] = cfg.TRAIN.BBOX_INSIDE_WEIGHTS\n return bbox_targets, bbox_inside_weights\n\ndef _vis_minibatch(im_blob, rois_blob, labels_blob, overlaps):\n \"\"\"Visualize a mini-batch for debugging.\"\"\"\n import matplotlib.pyplot as plt\n for i in xrange(rois_blob.shape[0]):\n rois = rois_blob[i, :]\n im_ind = rois[0]\n roi = rois[1:]\n im = im_blob[im_ind, :, :, :].transpose((1, 2, 0)).copy()\n im += cfg.PIXEL_MEANS\n im = im[:, :, (2, 1, 0)]\n im = im.astype(np.uint8)\n cls = labels_blob[i]\n plt.imshow(im)\n print 'class: ', cls, ' overlap: ', overlaps[i]\n plt.gca().add_patch(\n plt.Rectangle((roi[0], roi[1]), roi[2] - roi[0],\n roi[3] - roi[1], fill=False,\n edgecolor='r', linewidth=3)\n )\n plt.show()\n" }, { "path": "lib/roi_data_layer/roidb.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Transform a roidb into a trainable roidb by adding a bunch of metadata.\"\"\"\n\nimport numpy as np\nfrom fast_rcnn.config import cfg\nfrom fast_rcnn.bbox_transform import bbox_transform\nfrom utils.cython_bbox import bbox_overlaps\nimport PIL\n\ndef prepare_roidb(imdb):\n \"\"\"Enrich the imdb's roidb by adding some derived quantities that\n are useful for training. This function precomputes the maximum\n overlap, taken over ground-truth boxes, between each ROI and\n each ground-truth box. The class with maximum overlap is also\n recorded.\n \"\"\"\n sizes = [PIL.Image.open(imdb.image_path_at(i)).size\n for i in xrange(imdb.num_images)]\n roidb = imdb.roidb\n for i in xrange(len(imdb.image_index)):\n roidb[i]['image'] = imdb.image_path_at(i)\n roidb[i]['width'] = sizes[i][0]\n roidb[i]['height'] = sizes[i][1]\n # need gt_overlaps as a dense array for argmax\n gt_overlaps = roidb[i]['gt_overlaps'].toarray()\n # max overlap with gt over classes (columns)\n max_overlaps = gt_overlaps.max(axis=1)\n # gt class that had the max overlap\n max_classes = gt_overlaps.argmax(axis=1)\n roidb[i]['max_classes'] = max_classes\n roidb[i]['max_overlaps'] = max_overlaps\n # sanity checks\n # max overlap of 0 => class should be zero (background)\n zero_inds = np.where(max_overlaps == 0)[0]\n assert all(max_classes[zero_inds] == 0)\n # max overlap > 0 => class should not be zero (must be a fg class)\n nonzero_inds = np.where(max_overlaps > 0)[0]\n assert all(max_classes[nonzero_inds] != 0)\n\ndef add_bbox_regression_targets(roidb):\n \"\"\"Add information needed to train bounding-box regressors.\"\"\"\n assert len(roidb) > 0\n assert 'max_classes' in roidb[0], 'Did you call prepare_roidb first?'\n\n num_images = len(roidb)\n # Infer number of classes from the number of columns in gt_overlaps\n num_classes = roidb[0]['gt_overlaps'].shape[1]\n for im_i in xrange(num_images):\n rois = roidb[im_i]['boxes']\n max_overlaps = roidb[im_i]['max_overlaps']\n max_classes = roidb[im_i]['max_classes']\n roidb[im_i]['bbox_targets'] = \\\n _compute_targets(rois, max_overlaps, max_classes)\n\n if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:\n # Use fixed / precomputed \"means\" and \"stds\" instead of empirical values\n means = np.tile(\n np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS), (num_classes, 1))\n stds = np.tile(\n np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS), (num_classes, 1))\n else:\n # Compute values needed for means and stds\n # var(x) = E(x^2) - E(x)^2\n class_counts = np.zeros((num_classes, 1)) + cfg.EPS\n sums = np.zeros((num_classes, 4))\n squared_sums = np.zeros((num_classes, 4))\n for im_i in xrange(num_images):\n targets = roidb[im_i]['bbox_targets']\n for cls in xrange(1, num_classes):\n cls_inds = np.where(targets[:, 0] == cls)[0]\n if cls_inds.size > 0:\n class_counts[cls] += cls_inds.size\n sums[cls, :] += targets[cls_inds, 1:].sum(axis=0)\n squared_sums[cls, :] += \\\n (targets[cls_inds, 1:] ** 2).sum(axis=0)\n\n means = sums / class_counts\n stds = np.sqrt(squared_sums / class_counts - means ** 2)\n\n print 'bbox target means:'\n print means\n print means[1:, :].mean(axis=0) # ignore bg class\n print 'bbox target stdevs:'\n print stds\n print stds[1:, :].mean(axis=0) # ignore bg class\n\n # Normalize targets\n if cfg.TRAIN.BBOX_NORMALIZE_TARGETS:\n print \"Normalizing targets\"\n for im_i in xrange(num_images):\n targets = roidb[im_i]['bbox_targets']\n for cls in xrange(1, num_classes):\n cls_inds = np.where(targets[:, 0] == cls)[0]\n roidb[im_i]['bbox_targets'][cls_inds, 1:] -= means[cls, :]\n roidb[im_i]['bbox_targets'][cls_inds, 1:] /= stds[cls, :]\n else:\n print \"NOT normalizing targets\"\n\n # These values will be needed for making predictions\n # (the predicts will need to be unnormalized and uncentered)\n return means.ravel(), stds.ravel()\n\ndef _compute_targets(rois, overlaps, labels):\n \"\"\"Compute bounding-box regression targets for an image.\"\"\"\n # Indices of ground-truth ROIs\n gt_inds = np.where(overlaps == 1)[0]\n if len(gt_inds) == 0:\n # Bail if the image has no ground-truth ROIs\n return np.zeros((rois.shape[0], 5), dtype=np.float32)\n # Indices of examples for which we try to make predictions\n ex_inds = np.where(overlaps >= cfg.TRAIN.BBOX_THRESH)[0]\n\n # Get IoU overlap between each ex ROI and gt ROI\n ex_gt_overlaps = bbox_overlaps(\n np.ascontiguousarray(rois[ex_inds, :], dtype=np.float),\n np.ascontiguousarray(rois[gt_inds, :], dtype=np.float))\n\n # Find which gt ROI each ex ROI has max overlap with:\n # this will be the ex ROI's gt target\n gt_assignment = ex_gt_overlaps.argmax(axis=1)\n gt_rois = rois[gt_inds[gt_assignment], :]\n ex_rois = rois[ex_inds, :]\n\n targets = np.zeros((rois.shape[0], 5), dtype=np.float32)\n targets[ex_inds, 0] = labels[ex_inds]\n targets[ex_inds, 1:] = bbox_transform(ex_rois, gt_rois)\n return targets\n" }, { "path": "lib/rpn/README.md", "content": "### `rpn` module overview\n\n##### `generate_anchors.py`\n\nGenerates a regular grid of multi-scale, multi-aspect anchor boxes.\n\n##### `proposal_layer.py`\n\nConverts RPN outputs (per-anchor scores and bbox regression estimates) into object proposals.\n\n##### `anchor_target_layer.py` \n\nGenerates training targets/labels for each anchor. Classification labels are 1 (object), 0 (not object) or -1 (ignore).\nBbox regression targets are specified when the classification label is > 0.\n\n##### `proposal_target_layer.py`\n\nGenerates training targets/labels for each object proposal: classification labels 0 - K (bg or object class 1, ... , K)\nand bbox regression targets in that case that the label is > 0.\n\n##### `generate.py`\n\nGenerate object detection proposals from an imdb using an RPN.\n" }, { "path": "lib/rpn/__init__.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick and Sean Bell\n# --------------------------------------------------------\n" }, { "path": "lib/rpn/anchor_target_layer.py", "content": "# --------------------------------------------------------\n# Faster R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick and Sean Bell\n# --------------------------------------------------------\n\nimport os\nimport caffe\nimport yaml\nfrom fast_rcnn.config import cfg\nimport numpy as np\nimport numpy.random as npr\nfrom generate_anchors import generate_anchors\nfrom utils.cython_bbox import bbox_overlaps\nfrom fast_rcnn.bbox_transform import bbox_transform\n\nDEBUG = False\n\nclass AnchorTargetLayer(caffe.Layer):\n \"\"\"\n Assign anchors to ground-truth targets. Produces anchor classification\n labels and bounding-box regression targets.\n \"\"\"\n\n def setup(self, bottom, top):\n layer_params = yaml.load(self.param_str_)\n anchor_scales = layer_params.get('scales', (8, 16, 32))\n self._anchors = generate_anchors(scales=np.array(anchor_scales))\n self._num_anchors = self._anchors.shape[0]\n self._feat_stride = layer_params['feat_stride']\n\n if DEBUG:\n print 'anchors:'\n print self._anchors\n print 'anchor shapes:'\n print np.hstack((\n self._anchors[:, 2::4] - self._anchors[:, 0::4],\n self._anchors[:, 3::4] - self._anchors[:, 1::4],\n ))\n self._counts = cfg.EPS\n self._sums = np.zeros((1, 4))\n self._squared_sums = np.zeros((1, 4))\n self._fg_sum = 0\n self._bg_sum = 0\n self._count = 0\n\n # allow boxes to sit over the edge by a small amount\n self._allowed_border = layer_params.get('allowed_border', 0)\n\n height, width = bottom[0].data.shape[-2:]\n if DEBUG:\n print 'AnchorTargetLayer: height', height, 'width', width\n\n A = self._num_anchors\n # labels\n top[0].reshape(1, 1, A * height, width)\n # bbox_targets\n top[1].reshape(1, A * 4, height, width)\n # bbox_inside_weights\n top[2].reshape(1, A * 4, height, width)\n # bbox_outside_weights\n top[3].reshape(1, A * 4, height, width)\n\n def forward(self, bottom, top):\n # Algorithm:\n #\n # for each (H, W) location i\n # generate 9 anchor boxes centered on cell i\n # apply predicted bbox deltas at cell i to each of the 9 anchors\n # filter out-of-image anchors\n # measure GT overlap\n\n assert bottom[0].data.shape[0] == 1, \\\n 'Only single item batches are supported'\n\n # map of shape (..., H, W)\n height, width = bottom[0].data.shape[-2:]\n # GT boxes (x1, y1, x2, y2, label)\n gt_boxes = bottom[1].data\n # im_info\n im_info = bottom[2].data[0, :]\n\n if DEBUG:\n print ''\n print 'im_size: ({}, {})'.format(im_info[0], im_info[1])\n print 'scale: {}'.format(im_info[2])\n print 'height, width: ({}, {})'.format(height, width)\n print 'rpn: gt_boxes.shape', gt_boxes.shape\n print 'rpn: gt_boxes', gt_boxes\n\n # 1. Generate proposals from bbox deltas and shifted anchors\n shift_x = np.arange(0, width) * self._feat_stride\n shift_y = np.arange(0, height) * self._feat_stride\n shift_x, shift_y = np.meshgrid(shift_x, shift_y)\n shifts = np.vstack((shift_x.ravel(), shift_y.ravel(),\n shift_x.ravel(), shift_y.ravel())).transpose()\n # add A anchors (1, A, 4) to\n # cell K shifts (K, 1, 4) to get\n # shift anchors (K, A, 4)\n # reshape to (K*A, 4) shifted anchors\n A = self._num_anchors\n K = shifts.shape[0]\n all_anchors = (self._anchors.reshape((1, A, 4)) +\n shifts.reshape((1, K, 4)).transpose((1, 0, 2)))\n all_anchors = all_anchors.reshape((K * A, 4))\n total_anchors = int(K * A)\n\n # only keep anchors inside the image\n inds_inside = np.where(\n (all_anchors[:, 0] >= -self._allowed_border) &\n (all_anchors[:, 1] >= -self._allowed_border) &\n (all_anchors[:, 2] < im_info[1] + self._allowed_border) & # width\n (all_anchors[:, 3] < im_info[0] + self._allowed_border) # height\n )[0]\n\n if DEBUG:\n print 'total_anchors', total_anchors\n print 'inds_inside', len(inds_inside)\n\n # keep only inside anchors\n anchors = all_anchors[inds_inside, :]\n if DEBUG:\n print 'anchors.shape', anchors.shape\n\n # label: 1 is positive, 0 is negative, -1 is dont care\n labels = np.empty((len(inds_inside), ), dtype=np.float32)\n labels.fill(-1)\n\n # overlaps between the anchors and the gt boxes\n # overlaps (ex, gt)\n overlaps = bbox_overlaps(\n np.ascontiguousarray(anchors, dtype=np.float),\n np.ascontiguousarray(gt_boxes, dtype=np.float))\n argmax_overlaps = overlaps.argmax(axis=1)\n max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]\n gt_argmax_overlaps = overlaps.argmax(axis=0)\n gt_max_overlaps = overlaps[gt_argmax_overlaps,\n np.arange(overlaps.shape[1])]\n gt_argmax_overlaps = np.where(overlaps == gt_max_overlaps)[0]\n\n if not cfg.TRAIN.RPN_CLOBBER_POSITIVES:\n # assign bg labels first so that positive labels can clobber them\n labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0\n\n # fg label: for each gt, anchor with highest overlap\n labels[gt_argmax_overlaps] = 1\n\n # fg label: above threshold IOU\n labels[max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = 1\n\n if cfg.TRAIN.RPN_CLOBBER_POSITIVES:\n # assign bg labels last so that negative labels can clobber positives\n labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0\n\n # subsample positive labels if we have too many\n num_fg = int(cfg.TRAIN.RPN_FG_FRACTION * cfg.TRAIN.RPN_BATCHSIZE)\n fg_inds = np.where(labels == 1)[0]\n if len(fg_inds) > num_fg:\n disable_inds = npr.choice(\n fg_inds, size=(len(fg_inds) - num_fg), replace=False)\n labels[disable_inds] = -1\n\n # subsample negative labels if we have too many\n num_bg = cfg.TRAIN.RPN_BATCHSIZE - np.sum(labels == 1)\n bg_inds = np.where(labels == 0)[0]\n if len(bg_inds) > num_bg:\n disable_inds = npr.choice(\n bg_inds, size=(len(bg_inds) - num_bg), replace=False)\n labels[disable_inds] = -1\n #print \"was %s inds, disabling %s, now %s inds\" % (\n #len(bg_inds), len(disable_inds), np.sum(labels == 0))\n\n bbox_targets = np.zeros((len(inds_inside), 4), dtype=np.float32)\n bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])\n\n bbox_inside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)\n bbox_inside_weights[labels == 1, :] = np.array(cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS)\n\n bbox_outside_weights = np.zeros((len(inds_inside), 4), dtype=np.float32)\n if cfg.TRAIN.RPN_POSITIVE_WEIGHT < 0:\n # uniform weighting of examples (given non-uniform sampling)\n num_examples = np.sum(labels >= 0)\n positive_weights = np.ones((1, 4)) * 1.0 / num_examples\n negative_weights = np.ones((1, 4)) * 1.0 / num_examples\n else:\n assert ((cfg.TRAIN.RPN_POSITIVE_WEIGHT > 0) &\n (cfg.TRAIN.RPN_POSITIVE_WEIGHT < 1))\n positive_weights = (cfg.TRAIN.RPN_POSITIVE_WEIGHT /\n np.sum(labels == 1))\n negative_weights = ((1.0 - cfg.TRAIN.RPN_POSITIVE_WEIGHT) /\n np.sum(labels == 0))\n bbox_outside_weights[labels == 1, :] = positive_weights\n bbox_outside_weights[labels == 0, :] = negative_weights\n\n if DEBUG:\n self._sums += bbox_targets[labels == 1, :].sum(axis=0)\n self._squared_sums += (bbox_targets[labels == 1, :] ** 2).sum(axis=0)\n self._counts += np.sum(labels == 1)\n means = self._sums / self._counts\n stds = np.sqrt(self._squared_sums / self._counts - means ** 2)\n print 'means:'\n print means\n print 'stdevs:'\n print stds\n\n # map up to original set of anchors\n labels = _unmap(labels, total_anchors, inds_inside, fill=-1)\n bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, fill=0)\n bbox_inside_weights = _unmap(bbox_inside_weights, total_anchors, inds_inside, fill=0)\n bbox_outside_weights = _unmap(bbox_outside_weights, total_anchors, inds_inside, fill=0)\n\n if DEBUG:\n print 'rpn: max max_overlap', np.max(max_overlaps)\n print 'rpn: num_positive', np.sum(labels == 1)\n print 'rpn: num_negative', np.sum(labels == 0)\n self._fg_sum += np.sum(labels == 1)\n self._bg_sum += np.sum(labels == 0)\n self._count += 1\n print 'rpn: num_positive avg', self._fg_sum / self._count\n print 'rpn: num_negative avg', self._bg_sum / self._count\n\n # labels\n labels = labels.reshape((1, height, width, A)).transpose(0, 3, 1, 2)\n labels = labels.reshape((1, 1, A * height, width))\n top[0].reshape(*labels.shape)\n top[0].data[...] = labels\n\n # bbox_targets\n bbox_targets = bbox_targets \\\n .reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)\n top[1].reshape(*bbox_targets.shape)\n top[1].data[...] = bbox_targets\n\n # bbox_inside_weights\n bbox_inside_weights = bbox_inside_weights \\\n .reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)\n assert bbox_inside_weights.shape[2] == height\n assert bbox_inside_weights.shape[3] == width\n top[2].reshape(*bbox_inside_weights.shape)\n top[2].data[...] = bbox_inside_weights\n\n # bbox_outside_weights\n bbox_outside_weights = bbox_outside_weights \\\n .reshape((1, height, width, A * 4)).transpose(0, 3, 1, 2)\n assert bbox_outside_weights.shape[2] == height\n assert bbox_outside_weights.shape[3] == width\n top[3].reshape(*bbox_outside_weights.shape)\n top[3].data[...] = bbox_outside_weights\n\n def backward(self, top, propagate_down, bottom):\n \"\"\"This layer does not propagate gradients.\"\"\"\n pass\n\n def reshape(self, bottom, top):\n \"\"\"Reshaping happens during the call to forward.\"\"\"\n pass\n\n\ndef _unmap(data, count, inds, fill=0):\n \"\"\" Unmap a subset of item (data) back to the original set of items (of\n size count) \"\"\"\n if len(data.shape) == 1:\n ret = np.empty((count, ), dtype=np.float32)\n ret.fill(fill)\n ret[inds] = data\n else:\n ret = np.empty((count, ) + data.shape[1:], dtype=np.float32)\n ret.fill(fill)\n ret[inds, :] = data\n return ret\n\n\ndef _compute_targets(ex_rois, gt_rois):\n \"\"\"Compute bounding-box regression targets for an image.\"\"\"\n\n assert ex_rois.shape[0] == gt_rois.shape[0]\n assert ex_rois.shape[1] == 4\n assert gt_rois.shape[1] == 5\n\n return bbox_transform(ex_rois, gt_rois[:, :4]).astype(np.float32, copy=False)\n" }, { "path": "lib/rpn/generate.py", "content": "# --------------------------------------------------------\n# Faster R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nfrom fast_rcnn.config import cfg\nfrom utils.blob import im_list_to_blob\nfrom utils.timer import Timer\nimport numpy as np\nimport cv2\n\ndef _vis_proposals(im, dets, thresh=0.5):\n \"\"\"Draw detected bounding boxes.\"\"\"\n inds = np.where(dets[:, -1] >= thresh)[0]\n if len(inds) == 0:\n return\n\n class_name = 'obj'\n im = im[:, :, (2, 1, 0)]\n fig, ax = plt.subplots(figsize=(12, 12))\n ax.imshow(im, aspect='equal')\n for i in inds:\n bbox = dets[i, :4]\n score = dets[i, -1]\n\n ax.add_patch(\n plt.Rectangle((bbox[0], bbox[1]),\n bbox[2] - bbox[0],\n bbox[3] - bbox[1], fill=False,\n edgecolor='red', linewidth=3.5)\n )\n ax.text(bbox[0], bbox[1] - 2,\n '{:s} {:.3f}'.format(class_name, score),\n bbox=dict(facecolor='blue', alpha=0.5),\n fontsize=14, color='white')\n\n ax.set_title(('{} detections with '\n 'p({} | box) >= {:.1f}').format(class_name, class_name,\n thresh),\n fontsize=14)\n plt.axis('off')\n plt.tight_layout()\n plt.draw()\n\ndef _get_image_blob(im):\n \"\"\"Converts an image into a network input.\n\n Arguments:\n im (ndarray): a color image in BGR order\n\n Returns:\n blob (ndarray): a data blob holding an image pyramid\n im_scale_factors (list): list of image scales (relative to im) used\n in the image pyramid\n \"\"\"\n im_orig = im.astype(np.float32, copy=True)\n im_orig -= cfg.PIXEL_MEANS\n\n im_shape = im_orig.shape\n im_size_min = np.min(im_shape[0:2])\n im_size_max = np.max(im_shape[0:2])\n\n processed_ims = []\n\n assert len(cfg.TEST.SCALES) == 1\n target_size = cfg.TEST.SCALES[0]\n\n im_scale = float(target_size) / float(im_size_min)\n # Prevent the biggest axis from being more than MAX_SIZE\n if np.round(im_scale * im_size_max) > cfg.TEST.MAX_SIZE:\n im_scale = float(cfg.TEST.MAX_SIZE) / float(im_size_max)\n im = cv2.resize(im_orig, None, None, fx=im_scale, fy=im_scale,\n interpolation=cv2.INTER_LINEAR)\n im_info = np.hstack((im.shape[:2], im_scale))[np.newaxis, :]\n processed_ims.append(im)\n\n # Create a blob to hold the input images\n blob = im_list_to_blob(processed_ims)\n\n return blob, im_info\n\ndef im_proposals(net, im):\n \"\"\"Generate RPN proposals on a single image.\"\"\"\n blobs = {}\n blobs['data'], blobs['im_info'] = _get_image_blob(im)\n net.blobs['data'].reshape(*(blobs['data'].shape))\n net.blobs['im_info'].reshape(*(blobs['im_info'].shape))\n blobs_out = net.forward(\n data=blobs['data'].astype(np.float32, copy=False),\n im_info=blobs['im_info'].astype(np.float32, copy=False))\n\n scale = blobs['im_info'][0, 2]\n boxes = blobs_out['rois'][:, 1:].copy() / scale\n scores = blobs_out['scores'].copy()\n return boxes, scores\n\ndef imdb_proposals(net, imdb):\n \"\"\"Generate RPN proposals on all images in an imdb.\"\"\"\n\n _t = Timer()\n imdb_boxes = [[] for _ in xrange(imdb.num_images)]\n for i in xrange(imdb.num_images):\n im = cv2.imread(imdb.image_path_at(i))\n _t.tic()\n imdb_boxes[i], scores = im_proposals(net, im)\n _t.toc()\n print 'im_proposals: {:d}/{:d} {:.3f}s' \\\n .format(i + 1, imdb.num_images, _t.average_time)\n if 0:\n dets = np.hstack((imdb_boxes[i], scores))\n # from IPython import embed; embed()\n _vis_proposals(im, dets[:3, :], thresh=0.9)\n plt.show()\n\n return imdb_boxes\n" }, { "path": "lib/rpn/generate_anchors.py", "content": "# --------------------------------------------------------\n# Faster R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick and Sean Bell\n# --------------------------------------------------------\n\nimport numpy as np\n\n# Verify that we compute the same anchors as Shaoqing's matlab implementation:\n#\n# >> load output/rpn_cachedir/faster_rcnn_VOC2007_ZF_stage1_rpn/anchors.mat\n# >> anchors\n#\n# anchors =\n#\n# -83 -39 100 56\n# -175 -87 192 104\n# -359 -183 376 200\n# -55 -55 72 72\n# -119 -119 136 136\n# -247 -247 264 264\n# -35 -79 52 96\n# -79 -167 96 184\n# -167 -343 184 360\n\n#array([[ -83., -39., 100., 56.],\n# [-175., -87., 192., 104.],\n# [-359., -183., 376., 200.],\n# [ -55., -55., 72., 72.],\n# [-119., -119., 136., 136.],\n# [-247., -247., 264., 264.],\n# [ -35., -79., 52., 96.],\n# [ -79., -167., 96., 184.],\n# [-167., -343., 184., 360.]])\n\ndef generate_anchors(base_size=16, ratios=[0.5, 1, 2],\n scales=2**np.arange(3, 6)):\n \"\"\"\n Generate anchor (reference) windows by enumerating aspect ratios X\n scales wrt a reference (0, 0, 15, 15) window.\n \"\"\"\n\n base_anchor = np.array([1, 1, base_size, base_size]) - 1\n ratio_anchors = _ratio_enum(base_anchor, ratios)\n anchors = np.vstack([_scale_enum(ratio_anchors[i, :], scales)\n for i in xrange(ratio_anchors.shape[0])])\n return anchors\n\ndef _whctrs(anchor):\n \"\"\"\n Return width, height, x center, and y center for an anchor (window).\n \"\"\"\n\n w = anchor[2] - anchor[0] + 1\n h = anchor[3] - anchor[1] + 1\n x_ctr = anchor[0] + 0.5 * (w - 1)\n y_ctr = anchor[1] + 0.5 * (h - 1)\n return w, h, x_ctr, y_ctr\n\ndef _mkanchors(ws, hs, x_ctr, y_ctr):\n \"\"\"\n Given a vector of widths (ws) and heights (hs) around a center\n (x_ctr, y_ctr), output a set of anchors (windows).\n \"\"\"\n\n ws = ws[:, np.newaxis]\n hs = hs[:, np.newaxis]\n anchors = np.hstack((x_ctr - 0.5 * (ws - 1),\n y_ctr - 0.5 * (hs - 1),\n x_ctr + 0.5 * (ws - 1),\n y_ctr + 0.5 * (hs - 1)))\n return anchors\n\ndef _ratio_enum(anchor, ratios):\n \"\"\"\n Enumerate a set of anchors for each aspect ratio wrt an anchor.\n \"\"\"\n\n w, h, x_ctr, y_ctr = _whctrs(anchor)\n size = w * h\n size_ratios = size / ratios\n ws = np.round(np.sqrt(size_ratios))\n hs = np.round(ws * ratios)\n anchors = _mkanchors(ws, hs, x_ctr, y_ctr)\n return anchors\n\ndef _scale_enum(anchor, scales):\n \"\"\"\n Enumerate a set of anchors for each scale wrt an anchor.\n \"\"\"\n\n w, h, x_ctr, y_ctr = _whctrs(anchor)\n ws = w * scales\n hs = h * scales\n anchors = _mkanchors(ws, hs, x_ctr, y_ctr)\n return anchors\n\nif __name__ == '__main__':\n import time\n t = time.time()\n a = generate_anchors()\n print time.time() - t\n print a\n from IPython import embed; embed()\n" }, { "path": "lib/rpn/proposal_layer.py", "content": "# --------------------------------------------------------\n# Faster R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick and Sean Bell\n# --------------------------------------------------------\n\nimport caffe\nimport numpy as np\nimport yaml\nfrom fast_rcnn.config import cfg\nfrom generate_anchors import generate_anchors\nfrom fast_rcnn.bbox_transform import bbox_transform_inv, clip_boxes\nfrom fast_rcnn.nms_wrapper import nms\n\nDEBUG = False\n\nclass ProposalLayer(caffe.Layer):\n \"\"\"\n Outputs object detection proposals by applying estimated bounding-box\n transformations to a set of regular boxes (called \"anchors\").\n \"\"\"\n\n def setup(self, bottom, top):\n # parse the layer parameter string, which must be valid YAML\n layer_params = yaml.load(self.param_str_)\n\n self._feat_stride = layer_params['feat_stride']\n anchor_scales = layer_params.get('scales', (8, 16, 32))\n self._anchors = generate_anchors(scales=np.array(anchor_scales))\n self._num_anchors = self._anchors.shape[0]\n\n if DEBUG:\n print 'feat_stride: {}'.format(self._feat_stride)\n print 'anchors:'\n print self._anchors\n\n # rois blob: holds R regions of interest, each is a 5-tuple\n # (n, x1, y1, x2, y2) specifying an image batch index n and a\n # rectangle (x1, y1, x2, y2)\n top[0].reshape(1, 5)\n\n # scores blob: holds scores for R regions of interest\n if len(top) > 1:\n top[1].reshape(1, 1, 1, 1)\n\n def forward(self, bottom, top):\n # Algorithm:\n #\n # for each (H, W) location i\n # generate A anchor boxes centered on cell i\n # apply predicted bbox deltas at cell i to each of the A anchors\n # clip predicted boxes to image\n # remove predicted boxes with either height or width < threshold\n # sort all (proposal, score) pairs by score from highest to lowest\n # take top pre_nms_topN proposals before NMS\n # apply NMS with threshold 0.7 to remaining proposals\n # take after_nms_topN proposals after NMS\n # return the top proposals (-> RoIs top, scores top)\n\n assert bottom[0].data.shape[0] == 1, \\\n 'Only single item batches are supported'\n\n cfg_key = str(self.phase) # either 'TRAIN' or 'TEST'\n pre_nms_topN = cfg[cfg_key].RPN_PRE_NMS_TOP_N\n post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N\n nms_thresh = cfg[cfg_key].RPN_NMS_THRESH\n min_size = cfg[cfg_key].RPN_MIN_SIZE\n\n # the first set of _num_anchors channels are bg probs\n # the second set are the fg probs, which we want\n scores = bottom[0].data[:, self._num_anchors:, :, :]\n bbox_deltas = bottom[1].data\n im_info = bottom[2].data[0, :]\n\n if DEBUG:\n print 'im_size: ({}, {})'.format(im_info[0], im_info[1])\n print 'scale: {}'.format(im_info[2])\n\n # 1. Generate proposals from bbox deltas and shifted anchors\n height, width = scores.shape[-2:]\n\n if DEBUG:\n print 'score map size: {}'.format(scores.shape)\n\n # Enumerate all shifts\n shift_x = np.arange(0, width) * self._feat_stride\n shift_y = np.arange(0, height) * self._feat_stride\n shift_x, shift_y = np.meshgrid(shift_x, shift_y)\n shifts = np.vstack((shift_x.ravel(), shift_y.ravel(),\n shift_x.ravel(), shift_y.ravel())).transpose()\n\n # Enumerate all shifted anchors:\n #\n # add A anchors (1, A, 4) to\n # cell K shifts (K, 1, 4) to get\n # shift anchors (K, A, 4)\n # reshape to (K*A, 4) shifted anchors\n A = self._num_anchors\n K = shifts.shape[0]\n anchors = self._anchors.reshape((1, A, 4)) + \\\n shifts.reshape((1, K, 4)).transpose((1, 0, 2))\n anchors = anchors.reshape((K * A, 4))\n\n # Transpose and reshape predicted bbox transformations to get them\n # into the same order as the anchors:\n #\n # bbox deltas will be (1, 4 * A, H, W) format\n # transpose to (1, H, W, 4 * A)\n # reshape to (1 * H * W * A, 4) where rows are ordered by (h, w, a)\n # in slowest to fastest order\n bbox_deltas = bbox_deltas.transpose((0, 2, 3, 1)).reshape((-1, 4))\n\n # Same story for the scores:\n #\n # scores are (1, A, H, W) format\n # transpose to (1, H, W, A)\n # reshape to (1 * H * W * A, 1) where rows are ordered by (h, w, a)\n scores = scores.transpose((0, 2, 3, 1)).reshape((-1, 1))\n\n # Convert anchors into proposals via bbox transformations\n proposals = bbox_transform_inv(anchors, bbox_deltas)\n\n # 2. clip predicted boxes to image\n proposals = clip_boxes(proposals, im_info[:2])\n\n # 3. remove predicted boxes with either height or width < threshold\n # (NOTE: convert min_size to input image scale stored in im_info[2])\n keep = _filter_boxes(proposals, min_size * im_info[2])\n proposals = proposals[keep, :]\n scores = scores[keep]\n\n # 4. sort all (proposal, score) pairs by score from highest to lowest\n # 5. take top pre_nms_topN (e.g. 6000)\n order = scores.ravel().argsort()[::-1]\n if pre_nms_topN > 0:\n order = order[:pre_nms_topN]\n proposals = proposals[order, :]\n scores = scores[order]\n\n # 6. apply nms (e.g. threshold = 0.7)\n # 7. take after_nms_topN (e.g. 300)\n # 8. return the top proposals (-> RoIs top)\n keep = nms(np.hstack((proposals, scores)), nms_thresh)\n if post_nms_topN > 0:\n keep = keep[:post_nms_topN]\n proposals = proposals[keep, :]\n scores = scores[keep]\n\n # Output rois blob\n # Our RPN implementation only supports a single input image, so all\n # batch inds are 0\n batch_inds = np.zeros((proposals.shape[0], 1), dtype=np.float32)\n blob = np.hstack((batch_inds, proposals.astype(np.float32, copy=False)))\n top[0].reshape(*(blob.shape))\n top[0].data[...] = blob\n\n # [Optional] output scores blob\n if len(top) > 1:\n top[1].reshape(*(scores.shape))\n top[1].data[...] = scores\n\n def backward(self, top, propagate_down, bottom):\n \"\"\"This layer does not propagate gradients.\"\"\"\n pass\n\n def reshape(self, bottom, top):\n \"\"\"Reshaping happens during the call to forward.\"\"\"\n pass\n\ndef _filter_boxes(boxes, min_size):\n \"\"\"Remove all boxes with any side smaller than min_size.\"\"\"\n ws = boxes[:, 2] - boxes[:, 0] + 1\n hs = boxes[:, 3] - boxes[:, 1] + 1\n keep = np.where((ws >= min_size) & (hs >= min_size))[0]\n return keep\n" }, { "path": "lib/rpn/proposal_target_layer.py", "content": "# --------------------------------------------------------\n# Faster R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick and Sean Bell\n# --------------------------------------------------------\n\nimport caffe\nimport yaml\nimport numpy as np\nimport numpy.random as npr\nfrom fast_rcnn.config import cfg\nfrom fast_rcnn.bbox_transform import bbox_transform\nfrom utils.cython_bbox import bbox_overlaps\n\nDEBUG = False\n\nclass ProposalTargetLayer(caffe.Layer):\n \"\"\"\n Assign object detection proposals to ground-truth targets. Produces proposal\n classification labels and bounding-box regression targets.\n \"\"\"\n\n def setup(self, bottom, top):\n layer_params = yaml.load(self.param_str_)\n self._num_classes = layer_params['num_classes']\n\n # sampled rois (0, x1, y1, x2, y2)\n top[0].reshape(1, 5)\n # labels\n top[1].reshape(1, 1)\n # bbox_targets\n top[2].reshape(1, self._num_classes * 4)\n # bbox_inside_weights\n top[3].reshape(1, self._num_classes * 4)\n # bbox_outside_weights\n top[4].reshape(1, self._num_classes * 4)\n\n def forward(self, bottom, top):\n # Proposal ROIs (0, x1, y1, x2, y2) coming from RPN\n # (i.e., rpn.proposal_layer.ProposalLayer), or any other source\n all_rois = bottom[0].data\n # GT boxes (x1, y1, x2, y2, label)\n # TODO(rbg): it's annoying that sometimes I have extra info before\n # and other times after box coordinates -- normalize to one format\n gt_boxes = bottom[1].data\n\n # Include ground-truth boxes in the set of candidate rois\n zeros = np.zeros((gt_boxes.shape[0], 1), dtype=gt_boxes.dtype)\n all_rois = np.vstack(\n (all_rois, np.hstack((zeros, gt_boxes[:, :-1])))\n )\n\n # Sanity check: single batch only\n assert np.all(all_rois[:, 0] == 0), \\\n 'Only single item batches are supported'\n\n num_images = 1\n rois_per_image = cfg.TRAIN.BATCH_SIZE / num_images\n fg_rois_per_image = np.round(cfg.TRAIN.FG_FRACTION * rois_per_image)\n\n # Sample rois with classification labels and bounding box regression\n # targets\n labels, rois, bbox_targets, bbox_inside_weights = _sample_rois(\n all_rois, gt_boxes, fg_rois_per_image,\n rois_per_image, self._num_classes)\n\n if DEBUG:\n print 'num fg: {}'.format((labels > 0).sum())\n print 'num bg: {}'.format((labels == 0).sum())\n self._count += 1\n self._fg_num += (labels > 0).sum()\n self._bg_num += (labels == 0).sum()\n print 'num fg avg: {}'.format(self._fg_num / self._count)\n print 'num bg avg: {}'.format(self._bg_num / self._count)\n print 'ratio: {:.3f}'.format(float(self._fg_num) / float(self._bg_num))\n\n # sampled rois\n top[0].reshape(*rois.shape)\n top[0].data[...] = rois\n\n # classification labels\n top[1].reshape(*labels.shape)\n top[1].data[...] = labels\n\n # bbox_targets\n top[2].reshape(*bbox_targets.shape)\n top[2].data[...] = bbox_targets\n\n # bbox_inside_weights\n top[3].reshape(*bbox_inside_weights.shape)\n top[3].data[...] = bbox_inside_weights\n\n # bbox_outside_weights\n top[4].reshape(*bbox_inside_weights.shape)\n top[4].data[...] = np.array(bbox_inside_weights > 0).astype(np.float32)\n\n def backward(self, top, propagate_down, bottom):\n \"\"\"This layer does not propagate gradients.\"\"\"\n pass\n\n def reshape(self, bottom, top):\n \"\"\"Reshaping happens during the call to forward.\"\"\"\n pass\n\n\ndef _get_bbox_regression_labels(bbox_target_data, num_classes):\n \"\"\"Bounding-box regression targets (bbox_target_data) are stored in a\n compact form N x (class, tx, ty, tw, th)\n\n This function expands those targets into the 4-of-4*K representation used\n by the network (i.e. only one class has non-zero targets).\n\n Returns:\n bbox_target (ndarray): N x 4K blob of regression targets\n bbox_inside_weights (ndarray): N x 4K blob of loss weights\n \"\"\"\n\n clss = bbox_target_data[:, 0]\n bbox_targets = np.zeros((clss.size, 4 * num_classes), dtype=np.float32)\n bbox_inside_weights = np.zeros(bbox_targets.shape, dtype=np.float32)\n inds = np.where(clss > 0)[0]\n for ind in inds:\n cls = clss[ind]\n start = 4 * cls\n end = start + 4\n bbox_targets[ind, start:end] = bbox_target_data[ind, 1:]\n bbox_inside_weights[ind, start:end] = cfg.TRAIN.BBOX_INSIDE_WEIGHTS\n return bbox_targets, bbox_inside_weights\n\n\ndef _compute_targets(ex_rois, gt_rois, labels):\n \"\"\"Compute bounding-box regression targets for an image.\"\"\"\n\n assert ex_rois.shape[0] == gt_rois.shape[0]\n assert ex_rois.shape[1] == 4\n assert gt_rois.shape[1] == 4\n\n targets = bbox_transform(ex_rois, gt_rois)\n if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:\n # Optionally normalize targets by a precomputed mean and stdev\n targets = ((targets - np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS))\n / np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS))\n return np.hstack(\n (labels[:, np.newaxis], targets)).astype(np.float32, copy=False)\n\ndef _sample_rois(all_rois, gt_boxes, fg_rois_per_image, rois_per_image, num_classes):\n \"\"\"Generate a random sample of RoIs comprising foreground and background\n examples.\n \"\"\"\n # overlaps: (rois x gt_boxes)\n overlaps = bbox_overlaps(\n np.ascontiguousarray(all_rois[:, 1:5], dtype=np.float),\n np.ascontiguousarray(gt_boxes[:, :4], dtype=np.float))\n gt_assignment = overlaps.argmax(axis=1)\n max_overlaps = overlaps.max(axis=1)\n labels = gt_boxes[gt_assignment, 4]\n\n # Select foreground RoIs as those with >= FG_THRESH overlap\n fg_inds = np.where(max_overlaps >= cfg.TRAIN.FG_THRESH)[0]\n # Guard against the case when an image has fewer than fg_rois_per_image\n # foreground RoIs\n fg_rois_per_this_image = min(fg_rois_per_image, fg_inds.size)\n # Sample foreground regions without replacement\n if fg_inds.size > 0:\n fg_inds = npr.choice(fg_inds, size=fg_rois_per_this_image, replace=False)\n\n # Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)\n bg_inds = np.where((max_overlaps < cfg.TRAIN.BG_THRESH_HI) &\n (max_overlaps >= cfg.TRAIN.BG_THRESH_LO))[0]\n # Compute number of background RoIs to take from this image (guarding\n # against there being fewer than desired)\n bg_rois_per_this_image = rois_per_image - fg_rois_per_this_image\n bg_rois_per_this_image = min(bg_rois_per_this_image, bg_inds.size)\n # Sample background regions without replacement\n if bg_inds.size > 0:\n bg_inds = npr.choice(bg_inds, size=bg_rois_per_this_image, replace=False)\n\n # The indices that we're selecting (both fg and bg)\n keep_inds = np.append(fg_inds, bg_inds)\n # Select sampled values from various arrays:\n labels = labels[keep_inds]\n # Clamp labels for the background RoIs to 0\n labels[fg_rois_per_this_image:] = 0\n rois = all_rois[keep_inds]\n\n bbox_target_data = _compute_targets(\n rois[:, 1:5], gt_boxes[gt_assignment[keep_inds], :4], labels)\n\n bbox_targets, bbox_inside_weights = \\\n _get_bbox_regression_labels(bbox_target_data, num_classes)\n\n return labels, rois, bbox_targets, bbox_inside_weights\n" }, { "path": "lib/setup.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport numpy as np\nimport os\nfrom os.path import join as pjoin\n#from distutils.core import setup\nfrom setuptools import setup\nfrom distutils.extension import Extension\nfrom Cython.Distutils import build_ext\nimport subprocess\n\n#change for windows, by MrX\nnvcc_bin = 'nvcc.exe'\nlib_dir = 'lib/x64'\n\ndef find_in_path(name, path):\n \"Find a file in a search path\"\n # Adapted fom\n # http://code.activestate.com/recipes/52224-find-a-file-given-a-search-path/\n for dir in path.split(os.pathsep):\n binpath = pjoin(dir, name)\n if os.path.exists(binpath):\n return os.path.abspath(binpath)\n return None\n\n\ndef locate_cuda():\n \"\"\"Locate the CUDA environment on the system\n\n Returns a dict with keys 'home', 'nvcc', 'include', and 'lib64'\n and values giving the absolute path to each directory.\n\n Starts by looking for the CUDAHOME env variable. If not found, everything\n is based on finding 'nvcc' in the PATH.\n \"\"\"\n\n # first check if the CUDAHOME env variable is in use\n if 'CUDA_PATH' in os.environ:\n home = os.environ['CUDA_PATH']\n print(\"home = %s\\n\" % home)\n nvcc = pjoin(home, 'bin', nvcc_bin)\n else:\n # otherwise, search the PATH for NVCC\n default_path = pjoin(os.sep, 'usr', 'local', 'cuda', 'bin')\n nvcc = find_in_path(nvcc_bin, os.environ['PATH'] + os.pathsep + default_path)\n if nvcc is None:\n raise EnvironmentError('The nvcc binary could not be '\n 'located in your $PATH. Either add it to your path, or set $CUDA_PATH')\n home = os.path.dirname(os.path.dirname(nvcc))\n print(\"home = %s, nvcc = %s\\n\" % (home, nvcc))\n\n\n cudaconfig = {'home':home, 'nvcc':nvcc,\n 'include': pjoin(home, 'include'),\n 'lib64': pjoin(home, lib_dir)}\n for k, v in cudaconfig.iteritems():\n if not os.path.exists(v):\n raise EnvironmentError('The CUDA %s path could not be located in %s' % (k, v))\n\n return cudaconfig\nCUDA = locate_cuda()\n\n\n# Obtain the numpy include directory. This logic works across numpy versions.\ntry:\n numpy_include = np.get_include()\nexcept AttributeError:\n numpy_include = np.get_numpy_include()\n\n\ndef customize_compiler_for_nvcc(self):\n \"\"\"inject deep into distutils to customize how the dispatch\n to gcc/nvcc works.\n\n If you subclass UnixCCompiler, it's not trivial to get your subclass\n injected in, and still have the right customizations (i.e.\n distutils.sysconfig.customize_compiler) run on it. So instead of going\n the OO route, I have this. Note, it's kindof like a wierd functional\n subclassing going on.\"\"\"\n\n # tell the compiler it can processes .cu\n #self.src_extensions.append('.cu')\n\n\t\n # save references to the default compiler_so and _comple methods\n #default_compiler_so = self.spawn \n #default_compiler_so = self.rc\n super = self.compile\n\n # now redefine the _compile method. This gets executed for each\n # object but distutils doesn't have the ability to change compilers\n # based on source extension: we add it.\n def compile(sources, output_dir=None, macros=None, include_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, depends=None):\n postfix=os.path.splitext(sources[0])[1]\n \n if postfix == '.cu':\n # use the cuda for .cu files\n #self.set_executable('compiler_so', CUDA['nvcc'])\n # use only a subset of the extra_postargs, which are 1-1 translated\n # from the extra_compile_args in the Extension class\n postargs = extra_postargs['nvcc']\n else:\n postargs = extra_postargs['gcc']\n\n\n return super(sources, output_dir, macros, include_dirs, debug, extra_preargs, postargs, depends)\n # reset the default compiler_so, which we might have changed for cuda\n #self.rc = default_compiler_so\n\n # inject our redefined _compile method into the class\n self.compile = compile\n\n\n# run the customize_compiler\nclass custom_build_ext(build_ext):\n def build_extensions(self):\n customize_compiler_for_nvcc(self.compiler)\n build_ext.build_extensions(self)\n\n\next_modules = [\n # unix _compile: obj, src, ext, cc_args, extra_postargs, pp_opts\n Extension(\n \"utils.cython_bbox\",\n sources=[\"utils\\\\bbox.pyx\"],\n #define_macros={'/LD'},\n #extra_compile_args={'gcc': ['/link', '/DLL', '/OUT:cython_bbox.dll']},\n #extra_compile_args={'gcc': ['/LD']},\n extra_compile_args={'gcc': []},\n include_dirs = [numpy_include]\n ),\n Extension(\n \"nms.cpu_nms\",\n sources=[\"nms\\\\cpu_nms.pyx\"],\n extra_compile_args={'gcc': []},\n include_dirs = [numpy_include],\n ),\n Extension(\n \"pycocotools._mask\",\n sources=['pycocotools\\\\maskApi.c', 'pycocotools\\\\_mask.pyx'],\n include_dirs = [numpy_include, 'pycocotools'],\n extra_compile_args={\n 'gcc': ['/Qstd=c99']},\n ),\n #Extension( # just used to get nms\\gpu_nms.obj\n # \"nms.gpu_nms\",\n # sources=['nms\\\\gpu_nms.pyx'],\n # language='c++',\n # extra_compile_args={'gcc': []},\n # include_dirs = [numpy_include]\n #),\n]\n\nsetup(\n name='fast_rcnn',\n ext_modules=ext_modules,\n # inject our custom trigger\n cmdclass={'build_ext': custom_build_ext},\n)\n" }, { "path": "lib/setup_cuda.py", "content": "#!/usr/bin/env python\n\nimport numpy as np\nimport os\n# on Windows, we need the original PATH without Anaconda's compiler in it:\nPATH = os.environ.get('PATH')\nfrom distutils.spawn import spawn, find_executable\nfrom setuptools import setup, find_packages, Extension\nfrom setuptools.command.build_ext import build_ext\nimport sys\n\n# CUDA specific config\n# nvcc is assumed to be in user's PATH\nnvcc_compile_args = ['-O', '--ptxas-options=-v', '-arch=sm_35', '-c', '--compiler-options=-fPIC']\nnvcc_compile_args = os.environ.get('NVCCFLAGS', '').split() + nvcc_compile_args\ncuda_libs = ['cublas']\n\n\n# Obtain the numpy include directory. This logic works across numpy versions.\ntry:\n numpy_include = np.get_include()\nexcept AttributeError:\n numpy_include = np.get_numpy_include()\n\n\ncudamat_ext = Extension('nms.gpu_nms',\n sources=[\n 'nms\\\\gpu_nms.cu'\n ],\n language='c++',\n libraries=cuda_libs,\n extra_compile_args=nvcc_compile_args,\n include_dirs = [numpy_include, 'C:\\\\Programming\\\\CUDA\\\\v7.5\\\\include'])\n\n\nclass CUDA_build_ext(build_ext):\n \"\"\"\n Custom build_ext command that compiles CUDA files.\n Note that all extension source files will be processed with this compiler.\n \"\"\"\n def build_extensions(self):\n self.compiler.src_extensions.append('.cu')\n self.compiler.set_executable('compiler_so', 'nvcc')\n self.compiler.set_executable('linker_so', 'nvcc --shared')\n if hasattr(self.compiler, '_c_extensions'):\n self.compiler._c_extensions.append('.cu') # needed for Windows\n self.compiler.spawn = self.spawn\n build_ext.build_extensions(self)\n\n def spawn(self, cmd, search_path=1, verbose=0, dry_run=0):\n \"\"\"\n Perform any CUDA specific customizations before actually launching\n compile/link etc. commands.\n \"\"\"\n if (sys.platform == 'darwin' and len(cmd) >= 2 and cmd[0] == 'nvcc' and\n cmd[1] == '--shared' and cmd.count('-arch') > 0):\n # Versions of distutils on OSX earlier than 2.7.9 inject\n # '-arch x86_64' which we need to strip while using nvcc for\n # linking\n while True:\n try:\n index = cmd.index('-arch')\n del cmd[index:index+2]\n except ValueError:\n break\n elif self.compiler.compiler_type == 'msvc':\n # There are several things we need to do to change the commands\n # issued by MSVCCompiler into one that works with nvcc. In the end,\n # it might have been easier to write our own CCompiler class for\n # nvcc, as we're only interested in creating a shared library to\n # load with ctypes, not in creating an importable Python extension.\n # - First, we replace the cl.exe or link.exe call with an nvcc\n # call. In case we're running Anaconda, we search cl.exe in the\n # original search path we captured further above -- Anaconda\n # inserts a MSVC version into PATH that is too old for nvcc.\n cmd[:1] = ['nvcc', '--compiler-bindir',\n os.path.dirname(find_executable(\"cl.exe\", PATH))\n or cmd[0]]\n # - Secondly, we fix a bunch of command line arguments.\n for idx, c in enumerate(cmd):\n # create .dll instead of .pyd files\n #if '.pyd' in c: cmd[idx] = c = c.replace('.pyd', '.dll') #20160601, by MrX\n # replace /c by -c\n if c == '/c': cmd[idx] = '-c'\n # replace /DLL by --shared\n elif c == '/DLL': cmd[idx] = '--shared'\n # remove --compiler-options=-fPIC\n elif '-fPIC' in c: del cmd[idx]\n # replace /Tc... by ...\n elif c.startswith('/Tc'): cmd[idx] = c[3:]\n # replace /Fo... by -o ...\n elif c.startswith('/Fo'): cmd[idx:idx+1] = ['-o', c[3:]]\n # replace /LIBPATH:... by -L...\n elif c.startswith('/LIBPATH:'): cmd[idx] = '-L' + c[9:]\n # replace /OUT:... by -o ...\n elif c.startswith('/OUT:'): cmd[idx:idx+1] = ['-o', c[5:]]\n # remove /EXPORT:initlibcudamat or /EXPORT:initlibcudalearn\n elif c.startswith('/EXPORT:'): del cmd[idx]\n # replace cublas.lib by -lcublas\n elif c == 'cublas.lib': cmd[idx] = '-lcublas'\n # - Finally, we pass on all arguments starting with a '/' to the\n # compiler or linker, and have nvcc handle all other arguments\n if '--shared' in cmd:\n pass_on = '--linker-options='\n # we only need MSVCRT for a .dll, remove CMT if it sneaks in:\n cmd.append('/NODEFAULTLIB:libcmt.lib')\n else:\n pass_on = '--compiler-options='\n cmd = ([c for c in cmd if c[0] != '/'] +\n [pass_on + ','.join(c for c in cmd if c[0] == '/')])\n # For the future: Apart from the wrongly set PATH by Anaconda, it\n # would suffice to run the following for compilation on Windows:\n # nvcc -c -O -o .obj .cu\n # And the following for linking:\n # nvcc --shared -o .dll .obj .obj -lcublas\n # This could be done by a NVCCCompiler class for all platforms.\n spawn(cmd, search_path, verbose, dry_run)\n\nsetup(name=\"py_fast_rcnn_gpu\",\n description=\"Performs linear algebra computation on the GPU via CUDA\",\n ext_modules=[cudamat_ext],\n cmdclass={'build_ext': CUDA_build_ext},\n)\n" }, { "path": "lib/transform/__init__.py", "content": "" }, { "path": "lib/transform/torch_image_transform_layer.py", "content": "# --------------------------------------------------------\n# Fast/er R-CNN\n# Licensed under The MIT License [see LICENSE for details]\n# --------------------------------------------------------\n\n\"\"\" Transform images for compatibility with models trained with\nhttps://github.com/facebook/fb.resnet.torch.\n\nUsage in model prototxt:\n\nlayer {\n name: 'data_xform'\n type: 'Python'\n bottom: 'data_caffe'\n top: 'data'\n python_param {\n module: 'transform.torch_image_transform_layer'\n layer: 'TorchImageTransformLayer'\n }\n}\n\"\"\"\n\nimport caffe\nfrom fast_rcnn.config import cfg\nimport numpy as np\n\nclass TorchImageTransformLayer(caffe.Layer):\n def setup(self, bottom, top):\n # (1, 3, 1, 1) shaped arrays\n self.PIXEL_MEANS = \\\n np.array([[[[0.48462227599918]],\n [[0.45624044862054]],\n [[0.40588363755159]]]])\n self.PIXEL_STDS = \\\n np.array([[[[0.22889466674951]],\n [[0.22446679341259]],\n [[0.22495548344775]]]])\n # The default (\"old\") pixel means that were already subtracted\n channel_swap = (0, 3, 1, 2)\n self.OLD_PIXEL_MEANS = \\\n cfg.PIXEL_MEANS[np.newaxis, :, :, :].transpose(channel_swap)\n\n top[0].reshape(*(bottom[0].shape))\n\n def forward(self, bottom, top):\n ims = bottom[0].data\n # Invert the channel means that were already subtracted\n ims += self.OLD_PIXEL_MEANS\n # 1. Permute BGR to RGB and normalize to [0, 1]\n ims = ims[:, [2, 1, 0], :, :] / 255.0\n # 2. Remove channel means\n ims -= self.PIXEL_MEANS\n # 3. Standardize channels\n ims /= self.PIXEL_STDS\n top[0].reshape(*(ims.shape))\n top[0].data[...] = ims\n\n def backward(self, top, propagate_down, bottom):\n \"\"\"This layer does not propagate gradients.\"\"\"\n pass\n\n def reshape(self, bottom, top):\n \"\"\"Reshaping happens during the call to forward.\"\"\"\n pass\n" }, { "path": "lib/utils/.gitignore", "content": "*.c\n*.so\n" }, { "path": "lib/utils/__init__.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n" }, { "path": "lib/utils/bbox.pyx", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Sergey Karayev\n# --------------------------------------------------------\n\ncimport cython\nimport numpy as np\ncimport numpy as np\n\nDTYPE = np.float\nctypedef np.float_t DTYPE_t\n\ndef bbox_overlaps(\n np.ndarray[DTYPE_t, ndim=2] boxes,\n np.ndarray[DTYPE_t, ndim=2] query_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 overlap between boxes and query_boxes\n \"\"\"\n cdef unsigned int N = boxes.shape[0]\n cdef unsigned int K = query_boxes.shape[0]\n cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)\n cdef DTYPE_t iw, ih, box_area\n cdef DTYPE_t ua\n cdef unsigned int k, n\n for k in range(K):\n box_area = (\n (query_boxes[k, 2] - query_boxes[k, 0] + 1) *\n (query_boxes[k, 3] - query_boxes[k, 1] + 1)\n )\n for n in range(N):\n iw = (\n min(boxes[n, 2], query_boxes[k, 2]) -\n max(boxes[n, 0], query_boxes[k, 0]) + 1\n )\n if iw > 0:\n ih = (\n min(boxes[n, 3], query_boxes[k, 3]) -\n max(boxes[n, 1], query_boxes[k, 1]) + 1\n )\n if ih > 0:\n ua = float(\n (boxes[n, 2] - boxes[n, 0] + 1) *\n (boxes[n, 3] - boxes[n, 1] + 1) +\n box_area - iw * ih\n )\n overlaps[n, k] = iw * ih / ua\n return overlaps\n" }, { "path": "lib/utils/blob.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Blob helper functions.\"\"\"\n\nimport numpy as np\nimport cv2\n\ndef im_list_to_blob(ims):\n \"\"\"Convert a list of images into a network input.\n\n Assumes images are already prepared (means subtracted, BGR order, ...).\n \"\"\"\n max_shape = np.array([im.shape for im in ims]).max(axis=0)\n num_images = len(ims)\n blob = np.zeros((num_images, max_shape[0], max_shape[1], 3),\n dtype=np.float32)\n for i in xrange(num_images):\n im = ims[i]\n blob[i, 0:im.shape[0], 0:im.shape[1], :] = im\n # Move channels (axis 3) to axis 1\n # Axis order will become: (batch elem, channel, height, width)\n channel_swap = (0, 3, 1, 2)\n blob = blob.transpose(channel_swap)\n return blob\n\ndef prep_im_for_blob(im, pixel_means, target_size, max_size):\n \"\"\"Mean subtract and scale an image for use in a blob.\"\"\"\n im = im.astype(np.float32, copy=False)\n im -= pixel_means\n im_shape = im.shape\n im_size_min = np.min(im_shape[0:2])\n im_size_max = np.max(im_shape[0:2])\n im_scale = float(target_size) / float(im_size_min)\n # Prevent the biggest axis from being more than MAX_SIZE\n if np.round(im_scale * im_size_max) > max_size:\n im_scale = float(max_size) / float(im_size_max)\n im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale,\n interpolation=cv2.INTER_LINEAR)\n\n return im, im_scale\n" }, { "path": "lib/utils/timer.py", "content": "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\nimport time\n\nclass Timer(object):\n \"\"\"A simple timer.\"\"\"\n def __init__(self):\n self.total_time = 0.\n self.calls = 0\n self.start_time = 0.\n self.diff = 0.\n self.average_time = 0.\n\n def tic(self):\n # using time.time instead of time.clock because time time.clock\n # does not normalize for multithreading\n self.start_time = time.time()\n\n def toc(self, average=True):\n self.diff = time.time() - self.start_time\n self.total_time += self.diff\n self.calls += 1\n self.average_time = self.total_time / self.calls\n if average:\n return self.average_time\n else:\n return self.diff\n" } ]