From a71f10ec0803d6b4c2683dbdbb47be6a362b43b3 Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sun, 8 Nov 2020 16:46:58 -0800 Subject: [PATCH 01/43] initial slot machine algo and watershed bg removal --- misc/general_bg_rm.py | 73 ++++++++++++ tasks/slot_machine/slot_machine_test.py | 144 ++++++++++++++++++++++++ 2 files changed, 217 insertions(+) create mode 100644 misc/general_bg_rm.py create mode 100644 tasks/slot_machine/slot_machine_test.py diff --git a/misc/general_bg_rm.py b/misc/general_bg_rm.py new file mode 100644 index 0000000..27ce23d --- /dev/null +++ b/misc/general_bg_rm.py @@ -0,0 +1,73 @@ +import cv2 as cv +import numpy as np +import os +import argparse +parser = argparse.ArgumentParser() +parser.add_argument("file", help="file") +args = parser.parse_args() + + + +def resize_frame(frame,ratio = 0.4): + return cv.resize(frame,(int(frame.shape[1]*ratio),int(frame.shape[0]*ratio))) + +def save_frames(frames,folder): + os.mkdir(folder) + [cv.imwrite(f'{folder}/{frame}.png', frames[frame]) for frame in frames] + +def show_frames(frames): + [cv.imshow(frame,frames[frame]) for frame in frames] + +def analyze(src): + + # src = cv.imread(fn); + # src = resize_frame(src) + img = src + gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY) + ret, thresh = cv.threshold(gray,0,255,cv.THRESH_BINARY_INV+cv.THRESH_OTSU) + + # noise removal + kernel = np.ones((3,3),np.uint8) + opening = cv.morphologyEx(thresh,cv.MORPH_OPEN,kernel, iterations = 2) + # # sure background area + # sure_bg = cv.dilate(opening,kernel,iterations=3) + # # Finding sure foreground area + # dist_transform = cv.distanceTransform(opening,cv.DIST_L2,5) + # ret, sure_fg = cv.threshold(dist_transform,0.7*dist_transform.max(),255,0) + # # Finding unknown region + # sure_fg = np.uint8(sure_fg) + # unknown = cv.subtract(sure_bg,sure_fg) + + # # Marker labelling + # ret, markers = cv.connectedComponents(sure_fg) + # # Add one to all labels so that sure background is not 0, but 1 + # markers = markers+1 + # # Now, mark the region of unknown with zero + # markers[unknown==255] = 0 + # markers = cv.watershed(img,markers) + # orig = resize_frame(cv.imread(fn)) + # orig[markers == -1] = [255,0,0] + return thresh + # frames = {'test':thresh,'dist':dist_transform,'sure_fg':sure_fg,'sure_bg':sure_bg,'unknown':unknown,'marked':orig} + # show_frames(frames) + # save_frames(frames,'binary_inv_dc/orig') + # cv.waitKey() + + +if __name__ == '__main__': + print(args.file) + cap = cv.VideoCapture(args.file) + while not cap.isOpened(): + cap = cv.VideoCapture(args.file) + cv.waitKey(1000) + print ("Wait for the header") + while(True): + ret, frame = cap.read() + if ret: + cv.imshow('test',analyze(resize_frame(frame))) + if cv.waitKey(1) & 0xFF == ord('q'): + break + if cv.waitKey(32) == ord(' '): + while(not cv.waitKey(32) == ord(' ')): + continue + cv.waitKey(-1) \ No newline at end of file diff --git a/tasks/slot_machine/slot_machine_test.py b/tasks/slot_machine/slot_machine_test.py new file mode 100644 index 0000000..ce1f8c3 --- /dev/null +++ b/tasks/slot_machine/slot_machine_test.py @@ -0,0 +1,144 @@ +import numpy as np +import cv2 as cv +from utils import * + +def get_colors(frame, contour, x,y): + shaped = np.float32(frame.reshape(-1,3)) + x_curr = x[0] + y_curr = y[0] + # changed = [] + # for shape in shaped: + # if (cv.pointPolygonTest(contour,(x_curr,y_curr),False) >= 0): + # changed.append(shape) + # x_curr+=1 + # if(x_curr-1 == x[1]): + # # print(y_curr) + # x_curr = x[0] + # y_curr+=1 + # changed = np.float32(np.array(changed)) + # shaped = [shape for shape in shaped if cv.pointPolygonTest(contour,shape,False) >= 0] + n_colors = 2 + # print(changed,shaped) + criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 200, .1) + flags = cv.KMEANS_RANDOM_CENTERS + # print(len(shaped)-len(changed)) + # try: + # _, labels, palette = cv.kmeans(changed, n_colors, None, criteria, 10, flags) + # except: + _, labels, palette = cv.kmeans(shaped, n_colors, None, criteria, 10, flags) + + _, counts = np.unique(labels, return_counts=True) + ret = tuple(palette[np.argmax(counts)]) + ret = ( int (ret [ 0 ]), int (ret [ 1 ]), int (ret [ 2 ])) + # print(ret) + return ret + +def resize_frame(frame,ratio = 0.4): + return cv.resize(frame,(int(frame.shape[1]*ratio),int(frame.shape[0]*ratio))) + +cap = cv.VideoCapture("./water_spinner.MP4") +while not cap.isOpened(): + cap = cv.VideoCapture("./water_spinner.MP4") + cv.waitKey(1000) + print ("Wait for the header") + +while(True): + # Capture frame-by-frame + ret, frame = cap.read() + if ret: + frame = resize_frame(frame) + orig = frame + + bw_frame = cv.cvtColor(frame,cv.COLOR_RGB2GRAY) + high_thresh, thresh_im = cv.threshold((bw_frame), 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU) + # cv.imshow('thres',thresh_im) + lowThresh = 0.5*high_thresh + # print(high_thresh, lowThresh) + R,G,B = cv.split(frame) + # smooth = cv.bilateralFilter(frame,10,25,51) + smooth = cv.blur(frame,(2,2)) + # cv.imshow('test',smooth) + + # GENERATE CANNY EDGES + canny = cv.Canny(smooth, 100, high_thresh) + + sigma = 0.6 + v = np.median(smooth) + lower = int(max(0, (1.0 - sigma) * v)) + upper = int(min(255, (1.0 + sigma) * v)) + # print(lower, upper) + # canny = cv.Canny(smooth, lower, upper) + #TODO: ADD TO RET FRAMES + # cv.imshow('canny_new',canny) + + ## FIND CONTOURS + # _, contours, _ = cv.findContours(canny, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) + _, contours, _ = cv.findContours(canny, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) + outer_shell = np.zeros(frame.shape, np.uint8) + #keep only contours of more or less correct area and perimeter + cv.drawContours(outer_shell,contours,-1,(255,255,0),1) + cv.imshow('shell',outer_shell) + + w, h,c = frame.shape + blank = np.zeros((w, h)).astype(np.uint8) + cv.drawContours(blank, contours, -1, 1, 1) + blank = cv.morphologyEx(blank, cv.MORPH_CLOSE, np.ones((3, 3), np.uint8)) + _, contours, _ = cv.findContours(blank, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) + mask = np.zeros(frame.shape, np.uint8) + #keep only contours of more or less correct area and perimeter + contours = [c for c in contours if 100 < cv.contourArea(c) < 800] + cv.drawContours(mask,contours,-1,(255,255,0),1) + for i,c in enumerate(contours): + # mask = np.zeros(frame.shape, np.uint8) + # cv.drawContours(frame, c, -1,(0,0,255),1) + x,y,w,h = cv.boundingRect(c) # offsets - with this you get 'mask' + cimg = np.zeros_like(smooth) + # cv.imshow('cutted contour',frame[y:y+h,x:x+w]) + pts = cimg + # print(frame[c[1][0]]) + # arr = [] + # for v in c: + # try: + # arr.append(frame[v[0]]) + # except: + # pass + # arr = np.array(arr) + # np.array([frame[v[0]] for v in c]) + # get_colors(frame[y:y+h,x:x+w]) + # if 0.4 <= h/w <= 1.3 and 10 < len(cv.approxPolyDP(c, 0.01 * cv.arcLength(c, True), True)) and (cv.contourArea(c)/cv.arcLength(c, True)) > 0.5: + cv.rectangle(frame,(x,y),(x+w,y+h),get_colors(smooth[y:y+h,x:x+w],c,(y,y+h),(x,x+w)),2) + cv.imshow('res',frame) + # cv.imshow('eql',eql) + + # MASK TO SEE EDGES + + hulls = [] + usec = [] + for c in contours: + x,y,w,h = cv.boundingRect(c) + # if 10 < len(cv.approxPolyDP(c, 0.01 * cv.arcLength(c, True), True)) and (cv.contourArea(c)/cv.arcLength(c, True)) > 0.5: + hull = cv.convexHull(c) + # if cv.contourArea(hull)/cv.contourArea(c) > 0.8: + hulls.append(hull) + # cv.fillPoly(thresh_im, pts=[c], color=0) + usec.append(c) + # cv.drawContours(mask, c, -1, (0,255,0),1) + # top = sorted(list(zip(hulls,usec)),key= lambda h: cv.contourArea(h[0]) - cv.contourArea(h[1])) + # print(top) + # arr = np.array(top) + cv.drawContours(mask,hulls,-1,(255,0,0),1) + cv.drawContours(mask,usec,-1,(0,255,0),1) + cv.imshow('cont',mask) + + + # cv.imshow('orig',orig) + # cv.imshow('frame',frame) + if cv.waitKey(1) & 0xFF == ord('q'): + break + if cv.waitKey(32) == ord(' '): + while(not cv.waitKey(32) == ord(' ')): + continue + +# When everything done, release the capture +cap.release() +cv.destroyAllWindows() \ No newline at end of file From 4561021ba4d03b5f6fc12e07b3c22c3b7e092a00 Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sun, 8 Nov 2020 17:55:27 -0800 Subject: [PATCH 02/43] add haze and background removal initia files --- perception/misc/dark_channel/handler.py | 42 ++++++++++++++ perception/misc/dark_channel/haze_removal.py | 60 ++++++++++++++++++++ perception/misc/dark_channel/utils.py | 11 ++++ perception/misc/general_bg_rm.py | 13 ++++- 4 files changed, 125 insertions(+), 1 deletion(-) create mode 100644 perception/misc/dark_channel/handler.py create mode 100644 perception/misc/dark_channel/haze_removal.py create mode 100644 perception/misc/dark_channel/utils.py diff --git a/perception/misc/dark_channel/handler.py b/perception/misc/dark_channel/handler.py new file mode 100644 index 0000000..257f63a --- /dev/null +++ b/perception/misc/dark_channel/handler.py @@ -0,0 +1,42 @@ +import cv2 as cv +import numpy as np +from .haze_removal import HazeRemovel +from .utils import threshold_color_array +# from combinedFilter import init_combined_filter + +# cap = cv.VideoCapture('/Users/karthikdharmarajan/Documents/URobotics/Course Footage/GOPR1146.MP4') +# combined_filter = init_combined_filter() + +def rescale_frame(frame, percent=75): + width = int(frame.shape[1] * percent/ 100) + height = int(frame.shape[0] * percent/ 100) + dim = (width, height) + return cv.resize(frame, dim, interpolation =cv.INTER_AREA) + +def process_frame(frame): + haze_removal_object = HazeRemovel(frame) + dark_channel = haze_removal_object.get_dark_channel(haze_removal_object.I) + A = haze_removal_object.get_atmosphere(dark_channel) + t = haze_removal_object.get_transmission(dark_channel, A) + recover_image = haze_removal_object.get_recover_image(A, t) + return threshold_color_array(recover_image), t + +# while cap.isOpened(): +# ret, img_in = cap.read() + +# if ret: +# img_in = rescale_frame(img_in,30) +# recovered_img, depth_map = process_frame(img_in) +# thresholded_img_without_haze = cv.threshold(combined_filter(recovered_img), 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1] +# threshold_img_haze = cv.threshold(combined_filter(img_in), 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1] +# cv.imshow('img_in', img_in) +# cv.imshow('recovered_img', recovered_img) +# cv.imshow('thresholded_img_haze', threshold_img_haze) +# cv.imshow('threshold_img_without_haze', thresholded_img_without_haze) +# cv.imshow('depth_map', depth_map) + +# if cv.waitKey(1) & 0xFF == ord('q'): +# break + +# cap.release() +# cv.destroyAllWindows() diff --git a/perception/misc/dark_channel/haze_removal.py b/perception/misc/dark_channel/haze_removal.py new file mode 100644 index 0000000..8dc4737 --- /dev/null +++ b/perception/misc/dark_channel/haze_removal.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- + +import os + +from PIL import Image +import cv2 +import numpy as np + +from .utils import number_to_integral + + +class HazeRemovel: + + def __init__(self, image, refine=True, local_patch_size=15, + omega=0.95, percentage=0.001, tmin=0.1): + self.refine = refine + self.local_patch_size = local_patch_size + self.omega = omega + self.percentage = percentage + self.tmin = tmin + self.image = image + self.I = self.image.astype(np.float64) + self.height, self.width, _ = self.I.shape + + def get_dark_channel(self, image): + min_image = image.min(axis=2) + kernel = cv2.getStructuringElement( + cv2.MORPH_RECT, + (self.local_patch_size, self.local_patch_size) + ) + dark_channel = cv2.erode(min_image, kernel).astype(np.uint8) + return dark_channel + + def get_atmosphere(self, dark_channel): + img_size = self.height * self.width + flat_image = self.I.reshape(img_size, 3) + flat_dark = dark_channel.ravel() + pixel_count = number_to_integral(img_size * self.percentage) + search_idx = flat_dark.argsort()[-pixel_count:] + a = np.mean(flat_image.take(search_idx, axis=0), axis=0) + return a.astype(np.uint8) + + def get_transmission(self, dark_channel, A): + transmission = 1 - self.omega * \ + self.get_dark_channel(self.I / A * 255.0) / 255.0 + if self.refine: + transmission = self.get_refined_transmission(transmission) + return transmission + + def get_refined_transmission(self, transmission): + gray = self.image.min(axis=2) + t = (transmission * 255).astype(np.uint8) + refined_transmission = cv2.ximgproc.guidedFilter(gray, t, 40, 1e-2) + return refined_transmission / 255 + + def get_recover_image(self, A, transmission): + t = np.maximum(transmission, self.tmin) + tiled_t = np.zeros_like(self.I) + tiled_t[:, :, 0] = tiled_t[:, :, 1] = tiled_t[:, :, 2] = t + return (self.I - A) / tiled_t + A diff --git a/perception/misc/dark_channel/utils.py b/perception/misc/dark_channel/utils.py new file mode 100644 index 0000000..2f3a43e --- /dev/null +++ b/perception/misc/dark_channel/utils.py @@ -0,0 +1,11 @@ +# -*- coding: utf-8 -*- + +import numpy as np + + +def number_to_integral(number): + return int(np.ceil(number)) + + +def threshold_color_array(src): + return np.maximum(np.minimum(src, 255), 0).astype(np.uint8) diff --git a/perception/misc/general_bg_rm.py b/perception/misc/general_bg_rm.py index 27ce23d..0ee9c7e 100644 --- a/perception/misc/general_bg_rm.py +++ b/perception/misc/general_bg_rm.py @@ -5,9 +5,17 @@ parser = argparse.ArgumentParser() parser.add_argument("file", help="file") args = parser.parse_args() +from dark_channel.handler import process_frame as dark_channel +def DarkChannel(im): + b,g,r = cv.split(im) + dc = cv.min(cv.min(r,g),b); + kernel = cv.getStructuringElement(cv.MORPH_RECT,(im.shape[0],im.shape[1])) + dark = cv.erode(dc,kernel) + return dark + def resize_frame(frame,ratio = 0.4): return cv.resize(frame,(int(frame.shape[1]*ratio),int(frame.shape[0]*ratio))) @@ -64,7 +72,10 @@ def analyze(src): while(True): ret, frame = cap.read() if ret: - cv.imshow('test',analyze(resize_frame(frame))) + frame = resize_frame(frame, 0.25) + dark = dark_channel(frame)[0] + # cv.imshow('OTSU+Dark',analyze(dark)) + show_frames({'OTSU':analyze(frame),'dark':dark,'OTSU+DARK':analyze(dark),'orig':frame}) if cv.waitKey(1) & 0xFF == ord('q'): break if cv.waitKey(32) == ord(' '): From 2e15eb3a603103dc35e8608006b220ade42693a9 Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sun, 8 Nov 2020 16:46:58 -0800 Subject: [PATCH 03/43] initial slot machine algo and watershed bg removal --- misc/general_bg_rm.py | 73 ++++++++++++ tasks/slot_machine/slot_machine_test.py | 144 ++++++++++++++++++++++++ 2 files changed, 217 insertions(+) create mode 100644 misc/general_bg_rm.py create mode 100644 tasks/slot_machine/slot_machine_test.py diff --git a/misc/general_bg_rm.py b/misc/general_bg_rm.py new file mode 100644 index 0000000..27ce23d --- /dev/null +++ b/misc/general_bg_rm.py @@ -0,0 +1,73 @@ +import cv2 as cv +import numpy as np +import os +import argparse +parser = argparse.ArgumentParser() +parser.add_argument("file", help="file") +args = parser.parse_args() + + + +def resize_frame(frame,ratio = 0.4): + return cv.resize(frame,(int(frame.shape[1]*ratio),int(frame.shape[0]*ratio))) + +def save_frames(frames,folder): + os.mkdir(folder) + [cv.imwrite(f'{folder}/{frame}.png', frames[frame]) for frame in frames] + +def show_frames(frames): + [cv.imshow(frame,frames[frame]) for frame in frames] + +def analyze(src): + + # src = cv.imread(fn); + # src = resize_frame(src) + img = src + gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY) + ret, thresh = cv.threshold(gray,0,255,cv.THRESH_BINARY_INV+cv.THRESH_OTSU) + + # noise removal + kernel = np.ones((3,3),np.uint8) + opening = cv.morphologyEx(thresh,cv.MORPH_OPEN,kernel, iterations = 2) + # # sure background area + # sure_bg = cv.dilate(opening,kernel,iterations=3) + # # Finding sure foreground area + # dist_transform = cv.distanceTransform(opening,cv.DIST_L2,5) + # ret, sure_fg = cv.threshold(dist_transform,0.7*dist_transform.max(),255,0) + # # Finding unknown region + # sure_fg = np.uint8(sure_fg) + # unknown = cv.subtract(sure_bg,sure_fg) + + # # Marker labelling + # ret, markers = cv.connectedComponents(sure_fg) + # # Add one to all labels so that sure background is not 0, but 1 + # markers = markers+1 + # # Now, mark the region of unknown with zero + # markers[unknown==255] = 0 + # markers = cv.watershed(img,markers) + # orig = resize_frame(cv.imread(fn)) + # orig[markers == -1] = [255,0,0] + return thresh + # frames = {'test':thresh,'dist':dist_transform,'sure_fg':sure_fg,'sure_bg':sure_bg,'unknown':unknown,'marked':orig} + # show_frames(frames) + # save_frames(frames,'binary_inv_dc/orig') + # cv.waitKey() + + +if __name__ == '__main__': + print(args.file) + cap = cv.VideoCapture(args.file) + while not cap.isOpened(): + cap = cv.VideoCapture(args.file) + cv.waitKey(1000) + print ("Wait for the header") + while(True): + ret, frame = cap.read() + if ret: + cv.imshow('test',analyze(resize_frame(frame))) + if cv.waitKey(1) & 0xFF == ord('q'): + break + if cv.waitKey(32) == ord(' '): + while(not cv.waitKey(32) == ord(' ')): + continue + cv.waitKey(-1) \ No newline at end of file diff --git a/tasks/slot_machine/slot_machine_test.py b/tasks/slot_machine/slot_machine_test.py new file mode 100644 index 0000000..ce1f8c3 --- /dev/null +++ b/tasks/slot_machine/slot_machine_test.py @@ -0,0 +1,144 @@ +import numpy as np +import cv2 as cv +from utils import * + +def get_colors(frame, contour, x,y): + shaped = np.float32(frame.reshape(-1,3)) + x_curr = x[0] + y_curr = y[0] + # changed = [] + # for shape in shaped: + # if (cv.pointPolygonTest(contour,(x_curr,y_curr),False) >= 0): + # changed.append(shape) + # x_curr+=1 + # if(x_curr-1 == x[1]): + # # print(y_curr) + # x_curr = x[0] + # y_curr+=1 + # changed = np.float32(np.array(changed)) + # shaped = [shape for shape in shaped if cv.pointPolygonTest(contour,shape,False) >= 0] + n_colors = 2 + # print(changed,shaped) + criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 200, .1) + flags = cv.KMEANS_RANDOM_CENTERS + # print(len(shaped)-len(changed)) + # try: + # _, labels, palette = cv.kmeans(changed, n_colors, None, criteria, 10, flags) + # except: + _, labels, palette = cv.kmeans(shaped, n_colors, None, criteria, 10, flags) + + _, counts = np.unique(labels, return_counts=True) + ret = tuple(palette[np.argmax(counts)]) + ret = ( int (ret [ 0 ]), int (ret [ 1 ]), int (ret [ 2 ])) + # print(ret) + return ret + +def resize_frame(frame,ratio = 0.4): + return cv.resize(frame,(int(frame.shape[1]*ratio),int(frame.shape[0]*ratio))) + +cap = cv.VideoCapture("./water_spinner.MP4") +while not cap.isOpened(): + cap = cv.VideoCapture("./water_spinner.MP4") + cv.waitKey(1000) + print ("Wait for the header") + +while(True): + # Capture frame-by-frame + ret, frame = cap.read() + if ret: + frame = resize_frame(frame) + orig = frame + + bw_frame = cv.cvtColor(frame,cv.COLOR_RGB2GRAY) + high_thresh, thresh_im = cv.threshold((bw_frame), 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU) + # cv.imshow('thres',thresh_im) + lowThresh = 0.5*high_thresh + # print(high_thresh, lowThresh) + R,G,B = cv.split(frame) + # smooth = cv.bilateralFilter(frame,10,25,51) + smooth = cv.blur(frame,(2,2)) + # cv.imshow('test',smooth) + + # GENERATE CANNY EDGES + canny = cv.Canny(smooth, 100, high_thresh) + + sigma = 0.6 + v = np.median(smooth) + lower = int(max(0, (1.0 - sigma) * v)) + upper = int(min(255, (1.0 + sigma) * v)) + # print(lower, upper) + # canny = cv.Canny(smooth, lower, upper) + #TODO: ADD TO RET FRAMES + # cv.imshow('canny_new',canny) + + ## FIND CONTOURS + # _, contours, _ = cv.findContours(canny, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) + _, contours, _ = cv.findContours(canny, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) + outer_shell = np.zeros(frame.shape, np.uint8) + #keep only contours of more or less correct area and perimeter + cv.drawContours(outer_shell,contours,-1,(255,255,0),1) + cv.imshow('shell',outer_shell) + + w, h,c = frame.shape + blank = np.zeros((w, h)).astype(np.uint8) + cv.drawContours(blank, contours, -1, 1, 1) + blank = cv.morphologyEx(blank, cv.MORPH_CLOSE, np.ones((3, 3), np.uint8)) + _, contours, _ = cv.findContours(blank, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) + mask = np.zeros(frame.shape, np.uint8) + #keep only contours of more or less correct area and perimeter + contours = [c for c in contours if 100 < cv.contourArea(c) < 800] + cv.drawContours(mask,contours,-1,(255,255,0),1) + for i,c in enumerate(contours): + # mask = np.zeros(frame.shape, np.uint8) + # cv.drawContours(frame, c, -1,(0,0,255),1) + x,y,w,h = cv.boundingRect(c) # offsets - with this you get 'mask' + cimg = np.zeros_like(smooth) + # cv.imshow('cutted contour',frame[y:y+h,x:x+w]) + pts = cimg + # print(frame[c[1][0]]) + # arr = [] + # for v in c: + # try: + # arr.append(frame[v[0]]) + # except: + # pass + # arr = np.array(arr) + # np.array([frame[v[0]] for v in c]) + # get_colors(frame[y:y+h,x:x+w]) + # if 0.4 <= h/w <= 1.3 and 10 < len(cv.approxPolyDP(c, 0.01 * cv.arcLength(c, True), True)) and (cv.contourArea(c)/cv.arcLength(c, True)) > 0.5: + cv.rectangle(frame,(x,y),(x+w,y+h),get_colors(smooth[y:y+h,x:x+w],c,(y,y+h),(x,x+w)),2) + cv.imshow('res',frame) + # cv.imshow('eql',eql) + + # MASK TO SEE EDGES + + hulls = [] + usec = [] + for c in contours: + x,y,w,h = cv.boundingRect(c) + # if 10 < len(cv.approxPolyDP(c, 0.01 * cv.arcLength(c, True), True)) and (cv.contourArea(c)/cv.arcLength(c, True)) > 0.5: + hull = cv.convexHull(c) + # if cv.contourArea(hull)/cv.contourArea(c) > 0.8: + hulls.append(hull) + # cv.fillPoly(thresh_im, pts=[c], color=0) + usec.append(c) + # cv.drawContours(mask, c, -1, (0,255,0),1) + # top = sorted(list(zip(hulls,usec)),key= lambda h: cv.contourArea(h[0]) - cv.contourArea(h[1])) + # print(top) + # arr = np.array(top) + cv.drawContours(mask,hulls,-1,(255,0,0),1) + cv.drawContours(mask,usec,-1,(0,255,0),1) + cv.imshow('cont',mask) + + + # cv.imshow('orig',orig) + # cv.imshow('frame',frame) + if cv.waitKey(1) & 0xFF == ord('q'): + break + if cv.waitKey(32) == ord(' '): + while(not cv.waitKey(32) == ord(' ')): + continue + +# When everything done, release the capture +cap.release() +cv.destroyAllWindows() \ No newline at end of file From b1460ae1c2d2cbc6d7d3f5d2a129628b36b162df Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sun, 8 Nov 2020 17:55:27 -0800 Subject: [PATCH 04/43] add haze and background removal initia files --- misc/general_bg_rm.py | 13 ++++- perception/misc/dark_channel/handler.py | 42 ++++++++++++++ perception/misc/dark_channel/haze_removal.py | 60 ++++++++++++++++++++ perception/misc/dark_channel/utils.py | 11 ++++ 4 files changed, 125 insertions(+), 1 deletion(-) create mode 100644 perception/misc/dark_channel/handler.py create mode 100644 perception/misc/dark_channel/haze_removal.py create mode 100644 perception/misc/dark_channel/utils.py diff --git a/misc/general_bg_rm.py b/misc/general_bg_rm.py index 27ce23d..0ee9c7e 100644 --- a/misc/general_bg_rm.py +++ b/misc/general_bg_rm.py @@ -5,9 +5,17 @@ parser = argparse.ArgumentParser() parser.add_argument("file", help="file") args = parser.parse_args() +from dark_channel.handler import process_frame as dark_channel +def DarkChannel(im): + b,g,r = cv.split(im) + dc = cv.min(cv.min(r,g),b); + kernel = cv.getStructuringElement(cv.MORPH_RECT,(im.shape[0],im.shape[1])) + dark = cv.erode(dc,kernel) + return dark + def resize_frame(frame,ratio = 0.4): return cv.resize(frame,(int(frame.shape[1]*ratio),int(frame.shape[0]*ratio))) @@ -64,7 +72,10 @@ def analyze(src): while(True): ret, frame = cap.read() if ret: - cv.imshow('test',analyze(resize_frame(frame))) + frame = resize_frame(frame, 0.25) + dark = dark_channel(frame)[0] + # cv.imshow('OTSU+Dark',analyze(dark)) + show_frames({'OTSU':analyze(frame),'dark':dark,'OTSU+DARK':analyze(dark),'orig':frame}) if cv.waitKey(1) & 0xFF == ord('q'): break if cv.waitKey(32) == ord(' '): diff --git a/perception/misc/dark_channel/handler.py b/perception/misc/dark_channel/handler.py new file mode 100644 index 0000000..257f63a --- /dev/null +++ b/perception/misc/dark_channel/handler.py @@ -0,0 +1,42 @@ +import cv2 as cv +import numpy as np +from .haze_removal import HazeRemovel +from .utils import threshold_color_array +# from combinedFilter import init_combined_filter + +# cap = cv.VideoCapture('/Users/karthikdharmarajan/Documents/URobotics/Course Footage/GOPR1146.MP4') +# combined_filter = init_combined_filter() + +def rescale_frame(frame, percent=75): + width = int(frame.shape[1] * percent/ 100) + height = int(frame.shape[0] * percent/ 100) + dim = (width, height) + return cv.resize(frame, dim, interpolation =cv.INTER_AREA) + +def process_frame(frame): + haze_removal_object = HazeRemovel(frame) + dark_channel = haze_removal_object.get_dark_channel(haze_removal_object.I) + A = haze_removal_object.get_atmosphere(dark_channel) + t = haze_removal_object.get_transmission(dark_channel, A) + recover_image = haze_removal_object.get_recover_image(A, t) + return threshold_color_array(recover_image), t + +# while cap.isOpened(): +# ret, img_in = cap.read() + +# if ret: +# img_in = rescale_frame(img_in,30) +# recovered_img, depth_map = process_frame(img_in) +# thresholded_img_without_haze = cv.threshold(combined_filter(recovered_img), 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1] +# threshold_img_haze = cv.threshold(combined_filter(img_in), 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1] +# cv.imshow('img_in', img_in) +# cv.imshow('recovered_img', recovered_img) +# cv.imshow('thresholded_img_haze', threshold_img_haze) +# cv.imshow('threshold_img_without_haze', thresholded_img_without_haze) +# cv.imshow('depth_map', depth_map) + +# if cv.waitKey(1) & 0xFF == ord('q'): +# break + +# cap.release() +# cv.destroyAllWindows() diff --git a/perception/misc/dark_channel/haze_removal.py b/perception/misc/dark_channel/haze_removal.py new file mode 100644 index 0000000..8dc4737 --- /dev/null +++ b/perception/misc/dark_channel/haze_removal.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- + +import os + +from PIL import Image +import cv2 +import numpy as np + +from .utils import number_to_integral + + +class HazeRemovel: + + def __init__(self, image, refine=True, local_patch_size=15, + omega=0.95, percentage=0.001, tmin=0.1): + self.refine = refine + self.local_patch_size = local_patch_size + self.omega = omega + self.percentage = percentage + self.tmin = tmin + self.image = image + self.I = self.image.astype(np.float64) + self.height, self.width, _ = self.I.shape + + def get_dark_channel(self, image): + min_image = image.min(axis=2) + kernel = cv2.getStructuringElement( + cv2.MORPH_RECT, + (self.local_patch_size, self.local_patch_size) + ) + dark_channel = cv2.erode(min_image, kernel).astype(np.uint8) + return dark_channel + + def get_atmosphere(self, dark_channel): + img_size = self.height * self.width + flat_image = self.I.reshape(img_size, 3) + flat_dark = dark_channel.ravel() + pixel_count = number_to_integral(img_size * self.percentage) + search_idx = flat_dark.argsort()[-pixel_count:] + a = np.mean(flat_image.take(search_idx, axis=0), axis=0) + return a.astype(np.uint8) + + def get_transmission(self, dark_channel, A): + transmission = 1 - self.omega * \ + self.get_dark_channel(self.I / A * 255.0) / 255.0 + if self.refine: + transmission = self.get_refined_transmission(transmission) + return transmission + + def get_refined_transmission(self, transmission): + gray = self.image.min(axis=2) + t = (transmission * 255).astype(np.uint8) + refined_transmission = cv2.ximgproc.guidedFilter(gray, t, 40, 1e-2) + return refined_transmission / 255 + + def get_recover_image(self, A, transmission): + t = np.maximum(transmission, self.tmin) + tiled_t = np.zeros_like(self.I) + tiled_t[:, :, 0] = tiled_t[:, :, 1] = tiled_t[:, :, 2] = t + return (self.I - A) / tiled_t + A diff --git a/perception/misc/dark_channel/utils.py b/perception/misc/dark_channel/utils.py new file mode 100644 index 0000000..2f3a43e --- /dev/null +++ b/perception/misc/dark_channel/utils.py @@ -0,0 +1,11 @@ +# -*- coding: utf-8 -*- + +import numpy as np + + +def number_to_integral(number): + return int(np.ceil(number)) + + +def threshold_color_array(src): + return np.maximum(np.minimum(src, 255), 0).astype(np.uint8) From 1d320504b3bde64724036b49e7e3194e169090ec Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sun, 15 Nov 2020 15:26:09 -0800 Subject: [PATCH 05/43] Added depth_map as a TaskPerceiver --- perception/misc/dark_channel/dehaze.py | 15 +++++++ perception/misc/dark_channel/depth_map.py | 17 ++++++++ perception/misc/dark_channel/handler.py | 42 -------------------- perception/misc/dark_channel/haze_removal.py | 2 +- 4 files changed, 33 insertions(+), 43 deletions(-) create mode 100644 perception/misc/dark_channel/dehaze.py create mode 100644 perception/misc/dark_channel/depth_map.py delete mode 100644 perception/misc/dark_channel/handler.py diff --git a/perception/misc/dark_channel/dehaze.py b/perception/misc/dark_channel/dehaze.py new file mode 100644 index 0000000..19ec0f4 --- /dev/null +++ b/perception/misc/dark_channel/dehaze.py @@ -0,0 +1,15 @@ +import cv2 as cv +import numpy as np +from .haze_removal import HazeRemoval +from .utils import threshold_color_array +from ...vis.TaskPerceiver import TaskPerceiver + +class Dehaze(TaskPerceiver): + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + haze_removal_object = HazeRemoval(frame) + dark_channel = haze_removal_object.get_dark_channel(haze_removal_object.I) + A = haze_removal_object.get_atmosphere(dark_channel) + t = haze_removal_object.get_transmission(dark_channel, A) + recovered_image = haze_removal_object.get_recover_image(A, t) + return threshold_color_array(recovered_image) diff --git a/perception/misc/dark_channel/depth_map.py b/perception/misc/dark_channel/depth_map.py new file mode 100644 index 0000000..d73c1ac --- /dev/null +++ b/perception/misc/dark_channel/depth_map.py @@ -0,0 +1,17 @@ +import cv2 as cv +import numpy as np +from .haze_removal import HazeRemoval +from .utils import threshold_color_array +from ...vis.TaskPerceiver import TaskPerceiver + +class DepthMap(TaskPerceiver): + + def __init__(self, beta=1): + self.beta = beta + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + haze_removal_object = HazeRemoval(frame) + dark_channel = haze_removal_object.get_dark_channel(haze_removal_object.I) + A = haze_removal_object.get_atmosphere(dark_channel) + t = haze_removal_object.get_transmission(dark_channel, A) + return np.log(t) / -self.beta diff --git a/perception/misc/dark_channel/handler.py b/perception/misc/dark_channel/handler.py deleted file mode 100644 index 257f63a..0000000 --- a/perception/misc/dark_channel/handler.py +++ /dev/null @@ -1,42 +0,0 @@ -import cv2 as cv -import numpy as np -from .haze_removal import HazeRemovel -from .utils import threshold_color_array -# from combinedFilter import init_combined_filter - -# cap = cv.VideoCapture('/Users/karthikdharmarajan/Documents/URobotics/Course Footage/GOPR1146.MP4') -# combined_filter = init_combined_filter() - -def rescale_frame(frame, percent=75): - width = int(frame.shape[1] * percent/ 100) - height = int(frame.shape[0] * percent/ 100) - dim = (width, height) - return cv.resize(frame, dim, interpolation =cv.INTER_AREA) - -def process_frame(frame): - haze_removal_object = HazeRemovel(frame) - dark_channel = haze_removal_object.get_dark_channel(haze_removal_object.I) - A = haze_removal_object.get_atmosphere(dark_channel) - t = haze_removal_object.get_transmission(dark_channel, A) - recover_image = haze_removal_object.get_recover_image(A, t) - return threshold_color_array(recover_image), t - -# while cap.isOpened(): -# ret, img_in = cap.read() - -# if ret: -# img_in = rescale_frame(img_in,30) -# recovered_img, depth_map = process_frame(img_in) -# thresholded_img_without_haze = cv.threshold(combined_filter(recovered_img), 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1] -# threshold_img_haze = cv.threshold(combined_filter(img_in), 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1] -# cv.imshow('img_in', img_in) -# cv.imshow('recovered_img', recovered_img) -# cv.imshow('thresholded_img_haze', threshold_img_haze) -# cv.imshow('threshold_img_without_haze', thresholded_img_without_haze) -# cv.imshow('depth_map', depth_map) - -# if cv.waitKey(1) & 0xFF == ord('q'): -# break - -# cap.release() -# cv.destroyAllWindows() diff --git a/perception/misc/dark_channel/haze_removal.py b/perception/misc/dark_channel/haze_removal.py index 8dc4737..06d1b79 100644 --- a/perception/misc/dark_channel/haze_removal.py +++ b/perception/misc/dark_channel/haze_removal.py @@ -9,7 +9,7 @@ from .utils import number_to_integral -class HazeRemovel: +class HazeRemoval: def __init__(self, image, refine=True, local_patch_size=15, omega=0.95, percentage=0.001, tmin=0.1): From 23eb535671c676f90acdc5ebf88c7a59eba3fd1c Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sat, 21 Nov 2020 20:56:57 -0800 Subject: [PATCH 06/43] adapt Background Removal for the visualizer --- perception/misc/general_bg_rm.py | 84 ------------------- perception/vis/TestTasks/BackgroundRemoval.py | 35 ++++++++ .../vis/TestTasks/dark_channel/handler.py | 42 ++++++++++ .../TestTasks/dark_channel/haze_removal.py | 60 +++++++++++++ .../TestTasks}/dark_channel/utils.py | 0 5 files changed, 137 insertions(+), 84 deletions(-) delete mode 100644 perception/misc/general_bg_rm.py create mode 100644 perception/vis/TestTasks/BackgroundRemoval.py create mode 100644 perception/vis/TestTasks/dark_channel/handler.py create mode 100644 perception/vis/TestTasks/dark_channel/haze_removal.py rename perception/{misc => vis/TestTasks}/dark_channel/utils.py (100%) diff --git a/perception/misc/general_bg_rm.py b/perception/misc/general_bg_rm.py deleted file mode 100644 index 0ee9c7e..0000000 --- a/perception/misc/general_bg_rm.py +++ /dev/null @@ -1,84 +0,0 @@ -import cv2 as cv -import numpy as np -import os -import argparse -parser = argparse.ArgumentParser() -parser.add_argument("file", help="file") -args = parser.parse_args() -from dark_channel.handler import process_frame as dark_channel - - - -def DarkChannel(im): - b,g,r = cv.split(im) - dc = cv.min(cv.min(r,g),b); - kernel = cv.getStructuringElement(cv.MORPH_RECT,(im.shape[0],im.shape[1])) - dark = cv.erode(dc,kernel) - return dark - -def resize_frame(frame,ratio = 0.4): - return cv.resize(frame,(int(frame.shape[1]*ratio),int(frame.shape[0]*ratio))) - -def save_frames(frames,folder): - os.mkdir(folder) - [cv.imwrite(f'{folder}/{frame}.png', frames[frame]) for frame in frames] - -def show_frames(frames): - [cv.imshow(frame,frames[frame]) for frame in frames] - -def analyze(src): - - # src = cv.imread(fn); - # src = resize_frame(src) - img = src - gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY) - ret, thresh = cv.threshold(gray,0,255,cv.THRESH_BINARY_INV+cv.THRESH_OTSU) - - # noise removal - kernel = np.ones((3,3),np.uint8) - opening = cv.morphologyEx(thresh,cv.MORPH_OPEN,kernel, iterations = 2) - # # sure background area - # sure_bg = cv.dilate(opening,kernel,iterations=3) - # # Finding sure foreground area - # dist_transform = cv.distanceTransform(opening,cv.DIST_L2,5) - # ret, sure_fg = cv.threshold(dist_transform,0.7*dist_transform.max(),255,0) - # # Finding unknown region - # sure_fg = np.uint8(sure_fg) - # unknown = cv.subtract(sure_bg,sure_fg) - - # # Marker labelling - # ret, markers = cv.connectedComponents(sure_fg) - # # Add one to all labels so that sure background is not 0, but 1 - # markers = markers+1 - # # Now, mark the region of unknown with zero - # markers[unknown==255] = 0 - # markers = cv.watershed(img,markers) - # orig = resize_frame(cv.imread(fn)) - # orig[markers == -1] = [255,0,0] - return thresh - # frames = {'test':thresh,'dist':dist_transform,'sure_fg':sure_fg,'sure_bg':sure_bg,'unknown':unknown,'marked':orig} - # show_frames(frames) - # save_frames(frames,'binary_inv_dc/orig') - # cv.waitKey() - - -if __name__ == '__main__': - print(args.file) - cap = cv.VideoCapture(args.file) - while not cap.isOpened(): - cap = cv.VideoCapture(args.file) - cv.waitKey(1000) - print ("Wait for the header") - while(True): - ret, frame = cap.read() - if ret: - frame = resize_frame(frame, 0.25) - dark = dark_channel(frame)[0] - # cv.imshow('OTSU+Dark',analyze(dark)) - show_frames({'OTSU':analyze(frame),'dark':dark,'OTSU+DARK':analyze(dark),'orig':frame}) - if cv.waitKey(1) & 0xFF == ord('q'): - break - if cv.waitKey(32) == ord(' '): - while(not cv.waitKey(32) == ord(' ')): - continue - cv.waitKey(-1) \ No newline at end of file diff --git a/perception/vis/TestTasks/BackgroundRemoval.py b/perception/vis/TestTasks/BackgroundRemoval.py new file mode 100644 index 0000000..26e0aba --- /dev/null +++ b/perception/vis/TestTasks/BackgroundRemoval.py @@ -0,0 +1,35 @@ +import cv2 as cv +import numpy as np +from TaskPerceiver import TaskPerceiver +from typing import Dict +from .dark_channel.handler import process_frame as dark_channel + +class BackgroundRemoval(TaskPerceiver): + + def __init__(self, **kwargs): + super().__init__(blur = ((0, 10), 2)) + + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + blur = self.blur_frame(frame, size = slider_vals['blur']) + dark = dark_channel(blur)[0] + otsu_dark = self.threshold(dark) + clh = self.threshold(dark, clh = True) + no_blur = self.threshold(dark_channel(frame)[0], clh = True) + # print(blur.shape, dark.shape, otsu_dark.shape, clh.shape, no_blur.shape) + return no_blur, [otsu_dark, clh, no_blur, blur, dark, frame] + + def threshold(self, frame, x = 0, y =255, clh = False): + gray = cv.cvtColor(frame,cv.COLOR_BGR2GRAY) + if clh: + clahe = cv.createCLAHE(clipLimit=4.0, tileGridSize=(10,10)) + thresh = clahe.apply(gray) + _, thresh = cv.threshold(thresh,x,y,cv.THRESH_BINARY_INV+cv.THRESH_OTSU) + else: + _, thresh = cv.threshold(gray,x,y,cv.THRESH_BINARY_INV+cv.THRESH_OTSU) + + return thresh + + def blur_frame(self, frame, size = 15): + size = max(size, 1) + return cv.blur(frame,(size,size)) \ No newline at end of file diff --git a/perception/vis/TestTasks/dark_channel/handler.py b/perception/vis/TestTasks/dark_channel/handler.py new file mode 100644 index 0000000..257f63a --- /dev/null +++ b/perception/vis/TestTasks/dark_channel/handler.py @@ -0,0 +1,42 @@ +import cv2 as cv +import numpy as np +from .haze_removal import HazeRemovel +from .utils import threshold_color_array +# from combinedFilter import init_combined_filter + +# cap = cv.VideoCapture('/Users/karthikdharmarajan/Documents/URobotics/Course Footage/GOPR1146.MP4') +# combined_filter = init_combined_filter() + +def rescale_frame(frame, percent=75): + width = int(frame.shape[1] * percent/ 100) + height = int(frame.shape[0] * percent/ 100) + dim = (width, height) + return cv.resize(frame, dim, interpolation =cv.INTER_AREA) + +def process_frame(frame): + haze_removal_object = HazeRemovel(frame) + dark_channel = haze_removal_object.get_dark_channel(haze_removal_object.I) + A = haze_removal_object.get_atmosphere(dark_channel) + t = haze_removal_object.get_transmission(dark_channel, A) + recover_image = haze_removal_object.get_recover_image(A, t) + return threshold_color_array(recover_image), t + +# while cap.isOpened(): +# ret, img_in = cap.read() + +# if ret: +# img_in = rescale_frame(img_in,30) +# recovered_img, depth_map = process_frame(img_in) +# thresholded_img_without_haze = cv.threshold(combined_filter(recovered_img), 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1] +# threshold_img_haze = cv.threshold(combined_filter(img_in), 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1] +# cv.imshow('img_in', img_in) +# cv.imshow('recovered_img', recovered_img) +# cv.imshow('thresholded_img_haze', threshold_img_haze) +# cv.imshow('threshold_img_without_haze', thresholded_img_without_haze) +# cv.imshow('depth_map', depth_map) + +# if cv.waitKey(1) & 0xFF == ord('q'): +# break + +# cap.release() +# cv.destroyAllWindows() diff --git a/perception/vis/TestTasks/dark_channel/haze_removal.py b/perception/vis/TestTasks/dark_channel/haze_removal.py new file mode 100644 index 0000000..8dc4737 --- /dev/null +++ b/perception/vis/TestTasks/dark_channel/haze_removal.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- + +import os + +from PIL import Image +import cv2 +import numpy as np + +from .utils import number_to_integral + + +class HazeRemovel: + + def __init__(self, image, refine=True, local_patch_size=15, + omega=0.95, percentage=0.001, tmin=0.1): + self.refine = refine + self.local_patch_size = local_patch_size + self.omega = omega + self.percentage = percentage + self.tmin = tmin + self.image = image + self.I = self.image.astype(np.float64) + self.height, self.width, _ = self.I.shape + + def get_dark_channel(self, image): + min_image = image.min(axis=2) + kernel = cv2.getStructuringElement( + cv2.MORPH_RECT, + (self.local_patch_size, self.local_patch_size) + ) + dark_channel = cv2.erode(min_image, kernel).astype(np.uint8) + return dark_channel + + def get_atmosphere(self, dark_channel): + img_size = self.height * self.width + flat_image = self.I.reshape(img_size, 3) + flat_dark = dark_channel.ravel() + pixel_count = number_to_integral(img_size * self.percentage) + search_idx = flat_dark.argsort()[-pixel_count:] + a = np.mean(flat_image.take(search_idx, axis=0), axis=0) + return a.astype(np.uint8) + + def get_transmission(self, dark_channel, A): + transmission = 1 - self.omega * \ + self.get_dark_channel(self.I / A * 255.0) / 255.0 + if self.refine: + transmission = self.get_refined_transmission(transmission) + return transmission + + def get_refined_transmission(self, transmission): + gray = self.image.min(axis=2) + t = (transmission * 255).astype(np.uint8) + refined_transmission = cv2.ximgproc.guidedFilter(gray, t, 40, 1e-2) + return refined_transmission / 255 + + def get_recover_image(self, A, transmission): + t = np.maximum(transmission, self.tmin) + tiled_t = np.zeros_like(self.I) + tiled_t[:, :, 0] = tiled_t[:, :, 1] = tiled_t[:, :, 2] = t + return (self.I - A) / tiled_t + A diff --git a/perception/misc/dark_channel/utils.py b/perception/vis/TestTasks/dark_channel/utils.py similarity index 100% rename from perception/misc/dark_channel/utils.py rename to perception/vis/TestTasks/dark_channel/utils.py From ddc3d82802334904bf264458472145a9db7f8f5a Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sun, 22 Nov 2020 14:56:12 -0800 Subject: [PATCH 07/43] Added DepthMap With Histogram For Vis --- perception/vis/TestTasks/DepthMap.py | 101 +++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 perception/vis/TestTasks/DepthMap.py diff --git a/perception/vis/TestTasks/DepthMap.py b/perception/vis/TestTasks/DepthMap.py new file mode 100644 index 0000000..cb32582 --- /dev/null +++ b/perception/vis/TestTasks/DepthMap.py @@ -0,0 +1,101 @@ +import cv2 as cv +import numpy as np +from matplotlib import pyplot as plt +from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas +import matplotlib.ticker as ticker +from matplotlib.figure import Figure +from typing import Dict +from TaskPerceiver import TaskPerceiver + +def number_to_integral(number): + return int(np.ceil(number)) + +def threshold_color_array(src): + return np.maximum(np.minimum(src, 255), 0).astype(np.uint8) + +def output_histogram(img): + img_shape = img.shape + width, height = img_shape[1], img_shape[0] + fig = plt.figure(figsize=(width/180,height/180), dpi=180) + canvas = FigureCanvas(fig) + color = ('b','g','r') + color_labels=['Red','Green','Blue'] + axis = fig.add_subplot(1,1,1) + for i,col in enumerate(color): + histr = cv.calcHist([img],[i],None,[256],[0,256]) + axis.plot(np.arange(256), histr, c=color[i], label=color_labels[i]) + # Makes y-axis have a tick and a value associated with it every 2000 of value in y-axis + axis.yaxis.set_major_locator(ticker.MultipleLocator(2000)) + # Ensures that all labels and text is not cropped and is shown + plt.tight_layout() + # Forces pyplot to render image + fig.canvas.draw() + image = np.frombuffer(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) + plt.close() + return image + +class HazeRemoval: + + def __init__(self, image, refine=True, local_patch_size=15, + omega=0.95, percentage=0.001, tmin=0.1): + self.refine = refine + self.local_patch_size = local_patch_size + self.omega = omega + self.percentage = percentage + self.tmin = tmin + self.image = image + self.I = self.image.astype(np.float64) + self.height, self.width, _ = self.I.shape + + def get_dark_channel(self, image): + min_image = image.min(axis=2) + kernel = cv.getStructuringElement( + cv.MORPH_RECT, + (self.local_patch_size, self.local_patch_size) + ) + dark_channel = cv.erode(min_image, kernel).astype(np.uint8) + return dark_channel + + def get_atmosphere(self, dark_channel): + img_size = self.height * self.width + flat_image = self.I.reshape(img_size, 3) + flat_dark = dark_channel.ravel() + pixel_count = number_to_integral(img_size * self.percentage) + search_idx = flat_dark.argsort()[-pixel_count:] + a = np.mean(flat_image.take(search_idx, axis=0), axis=0) + return a.astype(np.uint8) + + def get_transmission(self, dark_channel, A): + transmission = 1 - self.omega * \ + self.get_dark_channel(self.I / A * 255.0) / 255.0 + if self.refine: + transmission = self.get_refined_transmission(transmission) + return transmission + + def get_refined_transmission(self, transmission): + gray = self.image.min(axis=2) + t = (transmission * 255).astype(np.uint8) + refined_transmission = cv.ximgproc.guidedFilter(gray, t, 40, 1e-2) + return refined_transmission / 255 + + def get_recover_image(self, A, transmission): + t = np.maximum(transmission, self.tmin) + tiled_t = np.zeros_like(self.I) + tiled_t[:, :, 0] = tiled_t[:, :, 1] = tiled_t[:, :, 2] = t + return (self.I - A) / tiled_t + A + +class DepthMap(TaskPerceiver): + + def __init__(self): + super().__init__(beta=((0, 10), 1)) + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + haze_removal_object = HazeRemoval(frame) + dark_channel = haze_removal_object.get_dark_channel(haze_removal_object.I) + A = haze_removal_object.get_atmosphere(dark_channel) + t = haze_removal_object.get_transmission(dark_channel, A) + depth_map = np.log(t) / -slider_vals['beta'] + histogram = output_histogram(frame) + return depth_map, [histogram, t, depth_map] + + From efa33f456da161ad15a1669eacb19ff3ea6d5e71 Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sun, 29 Nov 2020 10:07:43 -0800 Subject: [PATCH 08/43] PCA experimentation with Depth --- perception/vis/TestTasks/DepthMap.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/perception/vis/TestTasks/DepthMap.py b/perception/vis/TestTasks/DepthMap.py index cb32582..80667be 100644 --- a/perception/vis/TestTasks/DepthMap.py +++ b/perception/vis/TestTasks/DepthMap.py @@ -5,6 +5,7 @@ import matplotlib.ticker as ticker from matplotlib.figure import Figure from typing import Dict +from .combinedFilterDepthMap import init_combined_filter from TaskPerceiver import TaskPerceiver def number_to_integral(number): @@ -95,7 +96,13 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): A = haze_removal_object.get_atmosphere(dark_channel) t = haze_removal_object.get_transmission(dark_channel, A) depth_map = np.log(t) / -slider_vals['beta'] - histogram = output_histogram(frame) - return depth_map, [histogram, t, depth_map] + + # PCA Experimentation + stack = np.dstack((frame, t)).astype(np.uint8) + combined_filter = init_combined_filter() + depth_combined_pca = combined_filter(stack) + + pca = combined_filter(frame) + return depth_map, [t, depth_combined_pca[:,:,0], depth_map, pca[:,:,0]] From 960ec725e4fc8f71e248ee5773e45eb3c4d63304 Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sun, 29 Nov 2020 15:56:08 -0800 Subject: [PATCH 09/43] add temporal blur function to remove background artifacts --- perception/vis/TestTasks/BackgroundRemoval.py | 33 +++++++++++++++---- 1 file changed, 27 insertions(+), 6 deletions(-) diff --git a/perception/vis/TestTasks/BackgroundRemoval.py b/perception/vis/TestTasks/BackgroundRemoval.py index 26e0aba..1a84a43 100644 --- a/perception/vis/TestTasks/BackgroundRemoval.py +++ b/perception/vis/TestTasks/BackgroundRemoval.py @@ -4,29 +4,50 @@ from typing import Dict from .dark_channel.handler import process_frame as dark_channel + class BackgroundRemoval(TaskPerceiver): def __init__(self, **kwargs): - super().__init__(blur = ((0, 10), 2)) - + super().__init__(blur = ((0, 10), 2), lamda = ((0,10),1)) + self.prev_frame = None + + def gen_lamda_frame(self, frame, lamda): + return (frame*lamda).astype(np.uint8) + def calculate_blur(self, frame, lamda): + shape = frame.shape + dt = frame.dtype + if self.prev_frame is None: + # print(frame.dtype,self.gen_lamda_frame(shape,lamda,dt).dtype) + self.prev_frame = self.gen_lamda_frame(frame,lamda) + else: + self.prev_frame = cv.add(self.gen_lamda_frame(self.prev_frame,1-lamda), self.gen_lamda_frame(frame,lamda)) + return self.prev_frame def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): - blur = self.blur_frame(frame, size = slider_vals['blur']) + # print(frame.shape) + blur = frame + # self.calculate_blur(frame,slider_vals["lamda"]/10) + other = dark_channel(frame)[0] + other_dark = self.calculate_blur(other,slider_vals["blur"]/10) + other_otsu = self.threshold(other_dark) dark = dark_channel(blur)[0] otsu_dark = self.threshold(dark) clh = self.threshold(dark, clh = True) no_blur = self.threshold(dark_channel(frame)[0], clh = True) + # temp = np.zeros(no_blur.shape) + # print(no_blur.shape) + # cv.fastNlMeansDenoising(no_blur, temp, 10,10, 7, 21) # print(blur.shape, dark.shape, otsu_dark.shape, clh.shape, no_blur.shape) - return no_blur, [otsu_dark, clh, no_blur, blur, dark, frame] + return otsu_dark, [otsu_dark, clh, no_blur, blur, dark, frame, other, other_dark, other_otsu] def threshold(self, frame, x = 0, y =255, clh = False): gray = cv.cvtColor(frame,cv.COLOR_BGR2GRAY) if clh: clahe = cv.createCLAHE(clipLimit=4.0, tileGridSize=(10,10)) thresh = clahe.apply(gray) - _, thresh = cv.threshold(thresh,x,y,cv.THRESH_BINARY_INV+cv.THRESH_OTSU) + _, thresh = cv.threshold(thresh,x,y,cv.THRESH_BINARY+cv.THRESH_OTSU) else: - _, thresh = cv.threshold(gray,x,y,cv.THRESH_BINARY_INV+cv.THRESH_OTSU) + _, thresh = cv.threshold(gray,x,y,cv.THRESH_BINARY+cv.THRESH_OTSU) return thresh From 2743f1d1042ea4561dc12a60ed574cb742739a97 Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sun, 17 Jan 2021 16:45:58 -0800 Subject: [PATCH 10/43] Cleaned Up Various Algorithms --- algo_stats | Bin 0 -> 24167 bytes .../dark_channel/handler.py | 0 perception/misc/dark_channel/haze_removal.py | 2 +- .../TestTasks => misc}/dark_channel/utils.py | 0 perception/vis/TestTasks/DepthMap.py | 9 +- perception/vis/TestTasks/RBD.py | 12 + perception/vis/TestTasks/binarise.py | 28 +++ .../TestTasks/dark_channel/haze_removal.py | 60 ----- perception/vis/TestTasks/saliency_mbd.py | 238 ++++++++++++++++++ perception/vis/algo_stats | Bin 5441 -> 20750 bytes 10 files changed, 286 insertions(+), 63 deletions(-) create mode 100644 algo_stats rename perception/{vis/TestTasks => misc}/dark_channel/handler.py (100%) rename perception/{vis/TestTasks => misc}/dark_channel/utils.py (100%) create mode 100644 perception/vis/TestTasks/RBD.py create mode 100644 perception/vis/TestTasks/binarise.py delete mode 100644 perception/vis/TestTasks/dark_channel/haze_removal.py create mode 100644 perception/vis/TestTasks/saliency_mbd.py diff --git a/algo_stats b/algo_stats new file mode 100644 index 0000000000000000000000000000000000000000..e46bda8caf8affbe60393563890fddb32392e47d GIT binary patch literal 24167 zcmcgU33yaR(t!}}`<62ht{@~FDu{6&2mwKm`w)d;k~}((Br`+LOb!MV5dlF36%h{v zL?s9+9w_34t|AEPu880$3dk=;K@m_8MgFSp>3;pDCvkVbpWpA>-Xc?7U0q#WT~%HE z{zy$cU+LDe1o-cKN=AVh%=P6YclP-GrZ=Z^vTu5F=X@&=1So5UnH>zcQj@IG$_WXq zAzysA&NP zcCTL0%UV_mCWQ^z9CT&eu&jY00hrTG<EraKUX3BweM;cv7)G^AP019b-z))kZr+&1^k|%<;hRa z0TuFiv)PLM417nLxC=e`R*olVy0h^|x8?PRf~i$1V%0hGWI1zUqI!a&=2+QIMeUDk ziVZ2~^G=@;t6Liq2!q;NmtfvpQS&XYC!c^u<>Cy&*QSb-W%-w0eOV$R*T*&B#=r>%Xya&+^Z|scaAdTypLLLEyo3Lz|r!z_t4r z*RFmR^?7o#(a3lx^^^o)mv(_4Xa{J>xTE!F2D+BHBp{ZsHi$UV%2xIQPp&85U2&0coy(!% zWT%}pO!>Yd6WIXM6vI#1TBOzk8j{<3{D}IYdWHmW0VbBe|NgV%W-#>>m=i&=a15cW zhry7MI$pCl=mz8Kaf66JkwHll=#|LLJtwxTIlE)CO9HwA{#h_`*@2(x8bkoj>DvlO zl_M!;{%o*vMhw%QzzIkk87c?IIixM|5Y98M#Fh0snfvXcE$7a-hyX5?#S7$F1>n7a z+mi32yamsv5Z1wZ5$!@&rnD+>)65+(^TEY)7nv5x4VpP_a0X$EI;@ZADrq>`vKN24 z51hW}xg4|jWp$7x7c^wp=Dv^pzOS|+0o;te;Fq$F&_t@c-Aq;8zyso!)5*z0n+$ZW zg551|a@3n;|F*n=G*5m$_^*m8e4Wtyn|DV3>9WVC$uN#%yK6ZA{&3zBbeEgMTC*l< zV|y6n;ZyBOTfEuN2-EJd!yUV#*2~vC3En{6&o5rR=b>f>NTeMgl?9=R)N$MAP|yck z_ayw44uOVLdwxp9KdGxhnp{}>aOeG37*0M@$`?yE$iI2pG{%qRo-pB>0QR3yL`kC5>^GJlG`QT-T1} zud5Y+UCROoT-uW$6V{MpO}90?{RhL4z@@U_iqjHxSeQG2vu%vCtqJF6uRu2b5tIl6 zHtw|w-H}QJs>fFJ5caBCDB`@G*yCns$gU55s@yT@H4sps01g1fN{3GR?v;c*>;Y&1Cd}v9f$-&w{TiWtM9P+uN~YyhgLC& z0R97&352q;^F0BUsW=1&n}rQ27~k-VYBya40bmpe)A4M+%BpRDplRC1%{2@n0FdYe zK(adG8q~4^f;3JUZ7w&wTskmi0f3lTw*u@|lXc6{ROD5+>!zN!oNy5V2>B-`!idcyevI%98kClIyo7r z;AGD?y=Wp*(L`WF##YX1n0B zT9is#^I`4n%Tc}%f$SG9ShaS5RQ4J)k@|}F!P0P!iSxd@MBiO5TAP!%?V`p3oKT+s zt5|2883>N^1o8su0mv0K~@e%J?Y4NJqp3Q2}fwQ#|xIL5O}wp9g$s7(hRf^ z=Z(BaYAIbE3mIoVyxU0ZmI%W;B*fSKsE9m{x}ug(*}5VJq$GpRPx-%>P!?pSsKryL zU}_-l6@PKt!t?kY+zZ8$8uoAR&H_&{?#{i>&Z^8BGPNPe{OrkQ{Us2lA>aax!ObV0 zti&2Jbk*EW?@q7RUjh`(9-tI&-)B3%`VJ_@LreQ59u zSzD1IYa0`8b(g6S$gW4Ptg;JxrA>e=u5X~n9}H0wQX?`KSjIxm2VoRa{bKvvJspl4 z5|BEFKhyX)PGMBfunGdXz9OgiFAHAx{hAwA8bkoNb(_Ro1;KR??z2|7AXN%H7DP?T z<`O+6iP&+e8GsGx9QTh+y~a+y?NNgWKu*Y(xcEupI0@ItDDqgr8%#`HDD3QA@Q+Wo zyIb@p0tnNG_(Iu~#ZMB)Nx6?)C^rvj-H`9~d#LGl^VAiKw$k8g5EJa`k|_uEl;&lb zCvHtLhyYNr(YLjZpktI6d$0>MiSOj8o8$?c12BAl!-(Rmp4~NiZkLs}8$tNA6&P}}zI@QDG{cRn=N zAOZlHU5zsH!X;v)8YNl1APwnIKkg8<7xymhV>Vq^DL2Sy&iEUtDa+^SHNHpJ4UG&U z09-y67Q7E)izH_IoPL==llac%Q`zvN%0Q~UTrE--@64z#7mTjI$shudY_L$Tnx_z= z6XLw4I~}_0uf27^nh78^%K1z%Rp)DF;59h}R$%{CSHDAM&ZPHSS_TmSeTr*|y=}Uk zo-k$MjAslYfb!;unU%kpqY^>z^n98@ZkUj{byw*VkZjx-tDqkro_xZS4s+s(*vAZd zTP$~c12r+o%5&>Vd!L;fqX???Wg)@eFsNi89va>4)t6gj8AJeb5pqDH^jXe{t;OHA zSiS47k`@LLK=i0kGGN;$eY5@OU=Kv_QNSrmo7uq3kZI2PyX~$hE|2Q!7}2N>oH1G& zD@_f@Il66Yg1%@?MMdhW3_c{(Z`rS(9WjUi!gO}*;NmBV;~c!T<~s0w!fY*=daG|; zum{+XBQr4ty5ArZZ~C(F(k1&1a9J*S9uX3wX!XI4(OEDxuw(oW;2y2Sga|fd!&ig4 zfAs7qLjte`Uk2>5N!X<(bn%u%GrCrDO#NU(Mo+(EcrQBGkbvlQ5B6%{34jR;S|sEP z$szG(oL`TR4ZQZwsD+u3M~DJq*GJHFR>}7HG5WWabpQ4VHJUEG1FqAffWQxeeG@uu z@BKD^+|(`e)C&eVwet24&z*h2*bp@;GteB?a~HyejE}-O@5Us(!$QB5vajgY(XSXp z0J=i{^hxHx9qZ;pG!g~qAeb^xv6EL1*AEQcSJ)e_B%%QDivhn?6+}?3Rg-rj0ucIW z&umqLr`~+0*-r51qkvN%^<0k7M~{~A;ZybW@aB(>(lR-W-Dn;NN4&Ebs@J>t&~ce1pzz z%6mD(AOZk8c}e0xwgSA!3P5o^zZ!Q*6`wce7Mx$#z$J(P^ek?RW_9Q1R07=+fKvoR z$}vfJv5@922<1cR5ZVNHh=p+$<~p&^D(XCnDiSnaYcTJ(vnFhIYiwv~{&R1E%XNBZ z+u9kQv!J<6hVVE=C$~EpB2bfpvlMWZVJTIl7MOu-C`j_c|G?_l3X$_%?Pu!TxYZy6 zfIa#F^q@OgH}J!ORX2K%u(M#>Mz33I@7nd=v-A2IL;#L%i8(%Jxl?H8NB%_DQiBM< zfnF624PN*uF8Qg=qw*dpnhmxi3OIUH@j%uE=3!rm@%#-$*lUM<)FwA+1=<>W9##0g zjba+oyz45xk<`l|hw5144&}V*zKVXi{Rgm9ls3-aDM=Z8^GaXuAz;_2ZGNY8vER^G$vCO)hq#Z-`~) z{@u4-|Mr|~!MshZoccoEOAho%ZRho}qRvP9o}BSoZ`jP0M$E4>^7$M`KbjKDmAFD7 z4d-9JX4FV`jN3TyKim6WtR~3EW6)C!l~b&+1mja%`?LgZn9ht9tcK&XNBX@jKa#Lq z$zOt&!x<7kOR9g+EeuK{fH=4L;wOpY9MXBHDOg3?s06MUZ^nlnBPq=icA8&(BJ5T^a%XF32HplKV5iy?31?!DkW|8Q(XX4l#$Y?>9| zNSeKo<`tZ#&BGgQhA&47i((sDbrYsL81EI~plp5sEGrBflkR3T6*bhZ^uzQ+MzbOuN%J2_^P^arvPeb% zVY(-lruZr9nI$sQ%lK?m1!#W4Y1(V9-AaWimb}8cRe*zhO6NhBCy&(n8>G?JP@j>Z zt)OcdqXA9Z0~mPMij2osq#NXuwYA6heDG<5-ojCAt1gf6HWEeipg>6 zM=sQjv-GP+f;YDxVvzNP3pR8QmB!mR8V(8wX_n!hiPQ@DS+RSehXx$9MJ_`oHRMLO zg|Fc_g|8{zqP;_3+4dM5OizDOck6R22LQjNI49LR)o`3NHN}IKYPpV z;3x8qz0m)s3jwR_C1}9fVg;s2(f5WVQ?y)1>m&wYl^-;l4>APtv5{*PEqiMRjOQSZ z8d%Fk<27>an35sm7M6uj6Y*8XrSL=`9;PQbO`A^*2l;##u;@Rqd5_byg~#JAShNn; zr5xD$*Bsz8nm4Kd2Wdh$l~C3Mnn+W({kBG}J5znHIEL;sWJQe*G#oJug%nK!k0w-_ zeEC3!i&rG4ta-O5TSpKafA>P)kEO5SOZsyFRhdSw9OpD_d!&^vh3P&%Oa(Y{7zjQS zD2sBE6dPA*(d)CCTn65@Z|~|0*EbjnEAVS9O$|rVyb)=RMEoQr$$8uAnTPvd-^n0d z$MtD;+n2rBnaft}D?o+HuR>lerp{BXvJp>zqHkfk8_@-~ZUOm58pNqFRQzmNGs9EI zjhR~G;Pfmu=Qy)=NzZ~EjRrin5LEE|tux*TKF}8g@HyhB2LVq$w-R>^y$rgaqu2+5 z9QOE)MUNMM+|(ZSCLET9i>ln+9os?~=^zNXe!eU8%gejL4bpntk$yXxOaz)Y@CCEu5B{X8zCo58y6y5WUTB9KjNNe! z1ROmFEUzfJBi2}=Pm7B#-8G(tXldw&yS#|tDW7(RUT4(y*Zr4w+X|QJ&5tiASkmhn zL!37DG6lnCXm#?b#32e*0e5Ur{!A<5NS9H~Sux-ht_X>*eRW3a{6~8bHdZL!C>%YhHb%cLvY&AjzOeGtdSSiWSQg-f@!K{s<0d-rpR!P_EHL9v1RqGg4E35HqRce4i} z(TfVj7|3^hqLg3i;#TNSU&G;&*tG<|o8X21aC^s}6AWVqK_kE_L+L}cUewod2Yu1> zWJR5Euv8qUH#A^X@HHjB&s3}GU&{}EJaT3?g9so_=0W@H!M*}4~6&p9Bsa)xD zXKge*FMi@*t>6229MBwvIBMa!h9hYL3HUf`9vP`uFbqqch^SG>ox1NM2; z6MT-*S6r^EJ0^EJeBD%o9IU$Ko5)>HpgCpAWQ##H4xPTP^!UsE5`%o%)VykEhqsvt zvm;xkeCk@u10Z=&ucHTMt$-;mV=O3Zt>NGlZJOFr4Ey-5YhPY^r9o~w_`}s@b8sm* zO=T%G94F0cOl*oV*|%qM&FlYwcZJ41;nOWU;aejuyw-4>G|Ta3yBlO$pzh-}MvMWP zlVZisy;%jvNmKLG#GM{#Qu_WOPXs+RFQ;iAGu*kaY>;11nom^Uu*9GZIf{K)jd;`B zp!tuGl0SgQ+Q~IB%cwbXJV^pc_Sb7)EUQ}cZhP3VK$^)hnm;1TITwp3S1u7Ut$^l6Jj z{3NeoQ5;o(ob@L(Q0)vAY--ws*X{l6ioW~#*(GV(E34s1nl&K*1vKFfOQk6WD{sN@PNS*eNSf1;CSf!c>&a^hz`NrYVHgwTB95BAlCF|?kg5+W z-D>`nqAs%tOl0hwxh!@n+`ohJq6&u9aO6}hoXU(?nvY(b*!t>EAzI+fWX2PZh9hW} z?FMp@hHiMv1PLo1mcy%D_*#j&0^Huhmn{SkX9dJh5=RU{F~fk#5$6z49R+2Xj$ybE z;Y%+9h%=1%N#clMtgq2PG;oLD(LssR$FVKARtX%YU!XkIW!G@z2w43|*+s1?obipH zfAN)6uR+YFYY)_Xq!8pEO~2UVYB)&KKCCsG{L>7O26+3kPaa)7t{7-W4{MvIhJ!R& z2#BwrXg<>ur5=$-p^ysSfA(;4yAS&S&1rn@wh0iLPUdY|KfyhvqoEh`@JsfHo&p%ifHB3#R?%0l>e0pJa@G}nl71GBnJ+oh_R*!`$N{j7i*Dmg+xYSd z{-FEXpKgBk4x8x;a3oE99x0Akd;R1EI`_H^TW>1Bku>Xpa^YPemVvRmLc5c{{|ys2 z-vjk2k$YU0Hbv#URfj>p&ua>aV*$kBT>K<)BuzWzqSBP7uXw5* zho*)jY2tT9Xc|{BdqsFbOCNYBJGIWJ7BetZdY#X`0vt)xt|nCZltmZs-F)nuv_D>m zM^nR*G_mB6z7fl3lYY;?aKpHxV48Z*&tCCnWxV+2rVLe*)`v|GCfep%!tdvgB;_qLu7 zG-q>~wsF#MoHVt$^S~5tFmIdh*?#{<#TT&WuHiUoY6>ea?QVN=QSFVzsIZ!Uq2VCS zb}*Z=7SO<_TnaoTS*E+tGK;{sbBlNDux>-(ch(Sj3od}L?of!IB(fNXqU-K3@m3Ew zNm)Y%uh{d#8ymq_6hN3ZWM-lw97&l48iRqngWH}Dls23FNVY+~A08QZFeQ&=f!K_f z;*7pQeAQFrSGp6SobtnUEj^<>m<2*~t1fUt-{k1_!Z#UJx_;^Qkp}s$N&!9h|-~`#+ucxmquU4~`V(JzV>P)2To+ne%CDt%f6LmVF4Q@KF-G zP>?0E15TmXg!n5~I7syh^Hj#$D4qLBWcz|K{ta2gkoy| zuK=nhzPnQ`Ce3(VEYIAWD<4bHWf=FtG%A&%gzB_pPU^m{i{b4Bx&+Cw!)iEUTC_c& z@;XeF=A>31|2d;BRH_F***19h?Ne?2v6o20L7KL8W_wH3N%=PH!R zv~^O$anejde3eg*50-S_^Z5DAX+Tpu?KB*u$?A6M;@shMa?)Ipcm<@O2a0 zkGg>QI4!lP;ULZLkldBn9OE<@j7{`oLj4T#c&FZ9PvCWcO5$cH;;RL3JhV~pk^U1% zdL1@TBEBkzjG^16pZaJ8*iPK;?fZi>{}88Xua|~{H1Udw7GYD&Y1*p&^|HZ9H@4}} zpFDY2(cI1ldjd`E^?h5RJl7(Q z>auD$lIA@~^Ik?%d8J)C?yeVK9d{aTBm&)je&&O7pjX{vY06BIsJ4iD_f`Tv4abJ` zDZTLdjYwwP#pL_j0T~>&5fCcF)qyV&;^!gp?v8&b(p`)du%ImVCgb;hQ2H%^IEAj_ zCy66Qp%-Bkn!xO!axeJmoTcY~Yyxjqw;gzSO!cFf)<9-P~ z6kh0{e5X+|vIyzkh4`xJlvz%3nIGqFK*NzVe?gk3I8BJ1qLqP1CJd+@Jh2fT$ac(F zyMOg2<`tkYEG%P*)V2x;I@s_929L9(Q0piLVjXFFw(XP>L|F{G_w{1K`!)roc zd|ptHarVfP--_FfFzBDiuUcmJ&!3iM%^d_8z#(@(e)IRkHnDAYHBRROHh&?$>hNa7lj(_A_VXSaF(jeSUW1Hk z`qo>YKlK@iBn6d3-834GWEZDMJ8-44#oTb)4M#RDnq`pTJ*y2Ea{2LiN~Pf-&AGrG ny&ao*v3&l}=8Idd{N#3nG|ss5mJQ@Spt%-tR6aGF9zFgSL0Gbn literal 0 HcmV?d00001 diff --git a/perception/vis/TestTasks/dark_channel/handler.py b/perception/misc/dark_channel/handler.py similarity index 100% rename from perception/vis/TestTasks/dark_channel/handler.py rename to perception/misc/dark_channel/handler.py diff --git a/perception/misc/dark_channel/haze_removal.py b/perception/misc/dark_channel/haze_removal.py index 06d1b79..8dc4737 100644 --- a/perception/misc/dark_channel/haze_removal.py +++ b/perception/misc/dark_channel/haze_removal.py @@ -9,7 +9,7 @@ from .utils import number_to_integral -class HazeRemoval: +class HazeRemovel: def __init__(self, image, refine=True, local_patch_size=15, omega=0.95, percentage=0.001, tmin=0.1): diff --git a/perception/vis/TestTasks/dark_channel/utils.py b/perception/misc/dark_channel/utils.py similarity index 100% rename from perception/vis/TestTasks/dark_channel/utils.py rename to perception/misc/dark_channel/utils.py diff --git a/perception/vis/TestTasks/DepthMap.py b/perception/vis/TestTasks/DepthMap.py index 80667be..d442580 100644 --- a/perception/vis/TestTasks/DepthMap.py +++ b/perception/vis/TestTasks/DepthMap.py @@ -89,6 +89,7 @@ class DepthMap(TaskPerceiver): def __init__(self): super().__init__(beta=((0, 10), 1)) + self.counter = 1300 def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): haze_removal_object = HazeRemoval(frame) @@ -96,13 +97,17 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): A = haze_removal_object.get_atmosphere(dark_channel) t = haze_removal_object.get_transmission(dark_channel, A) depth_map = np.log(t) / -slider_vals['beta'] - + depth_map = np.array(255/(np.amax(depth_map))*depth_map, np.uint8) + if self.counter % 100 == 0: + cv.imwrite('/Users/karthikdharmarajan/Downloads/DES_code-master/data/depth_map/img' + str(self.counter // 100) + '.jpg', depth_map) + cv.imwrite('/Users/karthikdharmarajan/Downloads/DES_code-master/data/rgb_img/img' + str(self.counter // 100) + '.jpg', frame) + self.counter += 1 # PCA Experimentation stack = np.dstack((frame, t)).astype(np.uint8) combined_filter = init_combined_filter() depth_combined_pca = combined_filter(stack) pca = combined_filter(frame) - return depth_map, [t, depth_combined_pca[:,:,0], depth_map, pca[:,:,0]] + return depth_map, [frame] diff --git a/perception/vis/TestTasks/RBD.py b/perception/vis/TestTasks/RBD.py new file mode 100644 index 0000000..1ca93f6 --- /dev/null +++ b/perception/vis/TestTasks/RBD.py @@ -0,0 +1,12 @@ +from TaskPerceiver import TaskPerceiver +from .saliency_mbd import get_saliency_mbd +from .binarise import binarise_saliency_map +import numpy as np +from typing import Dict + +class RBD(TaskPerceiver): + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + mbd = get_saliency_mbd(frame).astype('uint8') + binary_sal = binarise_saliency_map(mbd,method='adaptive') + return binary_sal, [frame, mbd, 255 * binary_sal.astype('uint8')] diff --git a/perception/vis/TestTasks/binarise.py b/perception/vis/TestTasks/binarise.py new file mode 100644 index 0000000..ae77506 --- /dev/null +++ b/perception/vis/TestTasks/binarise.py @@ -0,0 +1,28 @@ +import numpy as np + +def binarise_saliency_map(saliency_map,method='adaptive',threshold=0.5): + + # check if input is a numpy array + if type(saliency_map).__module__ != np.__name__: + print('Expected numpy array') + return None + + #check if input is 2D + if len(saliency_map.shape) != 2: + print('Saliency map must be 2D') + return None + + if method == 'fixed': + return (saliency_map > threshold) + + elif method == 'adaptive': + adaptive_threshold = 2.0 * saliency_map.mean() + return (saliency_map > adaptive_threshold) + + elif method == 'clustering': + print('Not yet implemented') + return None + + else: + print("Method must be one of fixed, adaptive or clustering") + return None diff --git a/perception/vis/TestTasks/dark_channel/haze_removal.py b/perception/vis/TestTasks/dark_channel/haze_removal.py deleted file mode 100644 index 8dc4737..0000000 --- a/perception/vis/TestTasks/dark_channel/haze_removal.py +++ /dev/null @@ -1,60 +0,0 @@ -# -*- coding: utf-8 -*- - -import os - -from PIL import Image -import cv2 -import numpy as np - -from .utils import number_to_integral - - -class HazeRemovel: - - def __init__(self, image, refine=True, local_patch_size=15, - omega=0.95, percentage=0.001, tmin=0.1): - self.refine = refine - self.local_patch_size = local_patch_size - self.omega = omega - self.percentage = percentage - self.tmin = tmin - self.image = image - self.I = self.image.astype(np.float64) - self.height, self.width, _ = self.I.shape - - def get_dark_channel(self, image): - min_image = image.min(axis=2) - kernel = cv2.getStructuringElement( - cv2.MORPH_RECT, - (self.local_patch_size, self.local_patch_size) - ) - dark_channel = cv2.erode(min_image, kernel).astype(np.uint8) - return dark_channel - - def get_atmosphere(self, dark_channel): - img_size = self.height * self.width - flat_image = self.I.reshape(img_size, 3) - flat_dark = dark_channel.ravel() - pixel_count = number_to_integral(img_size * self.percentage) - search_idx = flat_dark.argsort()[-pixel_count:] - a = np.mean(flat_image.take(search_idx, axis=0), axis=0) - return a.astype(np.uint8) - - def get_transmission(self, dark_channel, A): - transmission = 1 - self.omega * \ - self.get_dark_channel(self.I / A * 255.0) / 255.0 - if self.refine: - transmission = self.get_refined_transmission(transmission) - return transmission - - def get_refined_transmission(self, transmission): - gray = self.image.min(axis=2) - t = (transmission * 255).astype(np.uint8) - refined_transmission = cv2.ximgproc.guidedFilter(gray, t, 40, 1e-2) - return refined_transmission / 255 - - def get_recover_image(self, A, transmission): - t = np.maximum(transmission, self.tmin) - tiled_t = np.zeros_like(self.I) - tiled_t[:, :, 0] = tiled_t[:, :, 1] = tiled_t[:, :, 2] = t - return (self.I - A) / tiled_t + A diff --git a/perception/vis/TestTasks/saliency_mbd.py b/perception/vis/TestTasks/saliency_mbd.py new file mode 100644 index 0000000..42a8a51 --- /dev/null +++ b/perception/vis/TestTasks/saliency_mbd.py @@ -0,0 +1,238 @@ +import math +import sys +import operator +import networkx as nx +#import matplotlib.pyplot as plt +import numpy as np +import scipy.spatial.distance +import scipy.signal +import skimage +import skimage.io +from skimage.segmentation import slic +from skimage.util import img_as_float +from scipy.optimize import minimize +#import pdb + +def raster_scan(img,L,U,D): + n_rows = len(img) + n_cols = len(img[0]) + + for x in range(1,n_rows - 1): + for y in range(1,n_cols - 1): + ix = img[x][y] + d = D[x][y] + + u1 = U[x-1][y] + l1 = L[x-1][y] + + u2 = U[x][y-1] + l2 = L[x][y-1] + + b1 = max(u1,ix) - min(l1,ix) + b2 = max(u2,ix) - min(l2,ix) + + if d <= b1 and d <= b2: + continue + elif b1 < d and b1 <= b2: + D[x][y] = b1 + U[x][y] = max(u1,ix) + L[x][y] = min(l1,ix) + else: + D[x][y] = b2 + U[x][y] = max(u2,ix) + L[x][y] = min(l2,ix) + + return True + +def raster_scan_inv(img,L,U,D): + n_rows = len(img) + n_cols = len(img[0]) + + for x in range(n_rows - 2,1,-1): + for y in range(n_cols - 2,1,-1): + + ix = img[x][y] + d = D[x][y] + + u1 = U[x+1][y] + l1 = L[x+1][y] + + u2 = U[x][y+1] + l2 = L[x][y+1] + + b1 = max(u1,ix) - min(l1,ix) + b2 = max(u2,ix) - min(l2,ix) + + if d <= b1 and d <= b2: + continue + elif b1 < d and b1 <= b2: + D[x][y] = b1 + U[x][y] = max(u1,ix) + L[x][y] = min(l1,ix) + else: + D[x][y] = b2 + U[x][y] = max(u2,ix) + L[x][y] = min(l2,ix) + + return True + +def mbd(img, num_iters): + + if len(img.shape) != 2: + print('did not get 2d np array to fast mbd') + return None + if (img.shape[0] <= 3 or img.shape[1] <= 3): + print('image is too small') + return None + + L = np.copy(img) + U = np.copy(img) + D = float('Inf') * np.ones(img.shape) + D[0,:] = 0 + D[-1,:] = 0 + D[:,0] = 0 + D[:,-1] = 0 + + # unfortunately, iterating over numpy arrays is very slow + img_list = img.tolist() + L_list = L.tolist() + U_list = U.tolist() + D_list = D.tolist() + + for x in range(0,num_iters): + if x%2 == 1: + raster_scan(img_list,L_list,U_list,D_list) + else: + raster_scan_inv(img_list,L_list,U_list,D_list) + + return np.array(D_list) + + +def get_saliency_mbd(img,method='b'): + + # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + img_mean = np.mean(img,axis=(2)) + sal = mbd(img_mean,3) + + if method == 'b': + # get the background map + + # paper uses 30px for an image of size 300px, so we use 10% + (n_rows,n_cols,n_channels) = img.shape + img_size = math.sqrt(n_rows * n_cols) + border_thickness = int(math.floor(0.1 * img_size)) + + img_lab = img_as_float(skimage.color.rgb2lab(img)) + + px_left = img_lab[0:border_thickness,:,:] + px_right = img_lab[n_rows - border_thickness-1:-1,:,:] + + px_top = img_lab[:,0:border_thickness,:] + px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] + + px_mean_left = np.mean(px_left,axis=(0,1)) + px_mean_right = np.mean(px_right,axis=(0,1)) + px_mean_top = np.mean(px_top,axis=(0,1)) + px_mean_bottom = np.mean(px_bottom,axis=(0,1)) + + + px_left = px_left.reshape((n_cols*border_thickness,3)) + px_right = px_right.reshape((n_cols*border_thickness,3)) + + px_top = px_top.reshape((n_rows*border_thickness,3)) + px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) + + cov_left = np.cov(px_left.T) + cov_right = np.cov(px_right.T) + + cov_top = np.cov(px_top.T) + cov_bottom = np.cov(px_bottom.T) + + cov_left = np.linalg.inv(cov_left) + cov_right = np.linalg.inv(cov_right) + + cov_top = np.linalg.inv(cov_top) + cov_bottom = np.linalg.inv(cov_bottom) + + + u_left = np.zeros(sal.shape) + u_right = np.zeros(sal.shape) + u_top = np.zeros(sal.shape) + u_bottom = np.zeros(sal.shape) + + u_final = np.zeros(sal.shape) + img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) + + px_mean_left_2 = np.zeros((1,3)) + px_mean_left_2[0,:] = px_mean_left + + u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) + u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) + + px_mean_right_2 = np.zeros((1,3)) + px_mean_right_2[0,:] = px_mean_right + + u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) + u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) + + px_mean_top_2 = np.zeros((1,3)) + px_mean_top_2[0,:] = px_mean_top + + u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) + u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) + + px_mean_bottom_2 = np.zeros((1,3)) + px_mean_bottom_2[0,:] = px_mean_bottom + + u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) + u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) + + max_u_left = np.max(u_left) + max_u_right = np.max(u_right) + max_u_top = np.max(u_top) + max_u_bottom = np.max(u_bottom) + + u_left = u_left / max_u_left + u_right = u_right / max_u_right + u_top = u_top / max_u_top + u_bottom = u_bottom / max_u_bottom + + u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) + + u_final = (u_left + u_right + u_top + u_bottom) - u_max + + u_max_final = np.max(u_final) + sal_max = np.max(sal) + sal = sal / sal_max + u_final / u_max_final + + #postprocessing + + # apply centredness map + sal = sal / np.max(sal) + + s = np.mean(sal) + alpha = 50.0 + delta = alpha * math.sqrt(s) + + xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) + (w,h) = sal.shape + w2 = w/2.0 + h2 = h/2.0 + + C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / math.sqrt(np.power(w2,2) + np.power(h2,2)) + + sal = sal * C + + #increase bg/fg contrast + + def f(x): + b = 10.0 + return 1.0 / (1.0 + math.exp(-b*(x - 0.5))) + + fv = np.vectorize(f) + + sal = sal / np.max(sal) + + sal = fv(sal) + + return sal* 255.0 \ No newline at end of file diff --git a/perception/vis/algo_stats b/perception/vis/algo_stats index edd4cf5661573c93313bc05cc1650ad0680e24f1..c74b5560ebef71061b1dc83f110eb8bf38a2b47b 100644 GIT binary patch literal 20750 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 From 12438dcbb4581b1a412316fefb687dd809c52045 Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sun, 17 Jan 2021 16:53:31 -0800 Subject: [PATCH 11/43] Deleted algo_stats --- perception/vis/algo_stats | Bin 20750 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 perception/vis/algo_stats diff --git a/perception/vis/algo_stats b/perception/vis/algo_stats deleted file mode 100644 index c74b5560ebef71061b1dc83f110eb8bf38a2b47b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 20750 zcmcIs33wF6@(+Xn5`$cFMhM7Z6cP?Oe8fzYOYSRj35=6u(ixKMF1@?tSU^q@F^HTZ z$RUVwNl*b11cHL1+#o_kkwaw>Pz2-<^-Lrp2 zhu$tV)*k}@Za0j}R6S|Vl&B^tYO*s$Z4%{7jcSsV<5Ar}CXG;&J?{AEFn=h3X&Gop z-lYvoZtUI>&k5hk(A#}tpLMI$9hP&Kav}AW|hL#lT$^iu&tzz27dYtL1L(5fTTshk4QXwIQ;i;MUG)M`a#J zQ9a-eS#^M;GzYOL#9ra=S`~VjE2Owwsw2fvCPQ<3%wE>^)dOMJkcF{-3?F@HxWozc za{B*^m))92ZRS#v(-oq+V;$a1S59oQld7@qG{vRLNs1dg!2b#uURXi#WT=YUBezP4 zE~7nN2h_uc?CQWVT3HPK?Rh6MflhZ+&X%LNiL;mA_;J#CTwwE|z^?elgJyFr! z5Z@_UveofTs{k`>$h8sU4)i*kI1=1?*Sj05~1G<6J`dY?>H zB_lD%1yQf7Rg7*{LmO~Ip@%bZ{1#>E!Hj!^ z77r}m;(LqR&Q!@%2ZAXO&uCmXkX0DrP_sR9isDgZPzmM?R77vM5}dHwCc2ZtfKaoG zG|t4%n3(g~#GD`RqcD?%SVY<|R*}M;;6u$-q(nci0<;k{dmtGfZ%d z0MqD$AWVBA474euY9tK;wS*U};v4fo4PKFgqV+E8(e1v)N9#RIMKIr}$x3pXKGXL@ z|Au>A5TwQ*?`35Z2?Q)_riHe6v+M~3jR6fTLTwnUH^tB}f}+UY^zXyicpMtiZqlQz zeM?$PoWS0Uf+v2ApThF8tdCL|bU=JDFIjbnio*rU(@b+j1yU%P2Q3nqHPuIEPe2n$ z3!)|Rckbk{8==D`94i0bvZBwmvZ0qghF(QG!{9Fp%&)pi#pq=j!}{@ zG1SgJ0%HOj;_P^1P5Or!5+~5atm4D<-X_;X)$K`C-05z}7L;^YA2Xe!lnhx(Q6PsH zrOKEbxYL{&n3=((p{>W1ts<=WvW_3+gp3vjYzgXGEw5L+=>aa7 zsa{7iSoC``yoC)Z)9#aLH_pB&ae~$YG(dLu1qe3ex%|W$zqOntaUw9Q`O}ea1vyhm zR~1T?9LwBx`a;M{TXLV32qXS$>(UfAvu^o&paeFgPM0;i-U)eK;smBx55+-hkgGbP zU}ASt4{Qu#xZ{Xb?Os@sLQDpA4DL3LI!U(Iw z8x@Yv3Z1>$bbjzBQy{BCM(b zg5ug^F@3`H0UMSt1JfA+lgNnTCy{$t^NLQtldRhwEd(}@h2d(p3nC37BoikM(J>dY zl=O|iCrN}6;Kd0_K?*jc z)BK2*d%l3+V}y_OMd(t%U_)wrbF;@E2PR6Ku=mB9cMBfBzg}O7Fe2JWaQrR|hzQNy z!3imrnr+*KT=mxa`$$Abi7*0ufSHkh3ceT)k(8O~bOc@#t~<2$n`=v!K;JXM>WC8N zTZl$|eiXd2=SDreWam>7VT6wk2H}>jVvjh+DzAiD^AFTbtaD}1cP z2_J23h|9xGC^qEaQ}bNsoAr`75lFuMSdgHp&;+t%Q-Thmo%XMVww?lrt(F#vd22NX zCeayCW093?%`JPp(8ZP^S~)RqctoFW5@7_r-!N5#bmd*=BAQ?A36KB*0T2ry{{zqz zmV*@y(@RJ*Fu5|4b0GA8e5(_9g|>k|7nTpa0%Ogzs0LmUyEc0tAG|yxXd12XjGPQ3EjS4TF#H9J8fjG&UiRU{9j zvsAm+{B(&h;=c~AOeGtGOT_YsDqHL4Re-dK5k59nOTbvgl`wWNuSI!c4qhEMKEMAO z=wL>`>TAqlgCJCISBS%f6~?eD-VzrK&0n*sV9$nmqUeI{E9ziMt($N1ZSFn&eTguF z4XBbZR)LYWHPGdBYuPa{1M9-{T`D%D^W44bx2~=$al&WcZ`d$aVWOT0JJ94nDUqr% zeIU6}sROnjqS}B3Lz<0(e@i?2(uSMo;yK}?Fa{w!ZF{^Etmb$kp2F_a3NiLV2id;< zV7yhg#x_U53=G9wcZ}DQDz}r3x-R(NUjsGEMa?$J@q=3ojgUBj8Cb9Xm#HWq8!~VS zGw`y8c(54-7bD$jP%WE5nlr`;Ra1;1(XDBNZ@fDBe3V2OffH-=Rb8Ed^(=Km|<(@p9MRPeWbQ+|edg3QmVrUa3K`U^W?Eam%lRq#`2BhOtU- zWs`2~X;Jvo-qchTGP8c5mtMKx!DiB-_N}dFR(645%?KRUx;sXpJMKrLWIgqDx-4#C zc>bbQu~@E{TUFEVQ7Kzh+(*X-hqnz=oct^biGWZb5oWfoy#wVoOUH<1r)h`CU(U3t zAQ47jj5Gla{MDc-tSrNhF{{{$5_^fiZPhFyE=lubX>M3b9Vs}+iut-qi$*igtKUn6 z5hynSL~6^hGon(VaG+Az>GjBIP)LHUt+7kZ^k#T8NIETv4CBF>S=A^Pr&1X2Rt5gp z5YzhU?d1{(BS3-M!-^l^|Lb17BUJFydMYj~)3rjER>B>3ibB)nWZ0`YRH)IJ{KB;1 zYFSOG5eIMg_fV(4Fv3UisKO$LJ>nRvoJuGsk-|Ab zl0y49_54~a|KCTx_jTPrW=ez+IFc}Bpq0<>X`D>!y^PwSAdfcj%nD?H< z35>}+c;X+9V#>i8T}DnWrfmo><{hh~@^Mgefn3sR((ahPpR~?DArVHf#oc5Ad&DtT z#`nc#DVnFdnq%eMZp(%qFTUS5fiS{HXM?U5=dec{W93{ij(D{cHKnsY0v);a1i}a&d~q0jdL>iwWIEk0s8`{Zt%O&tN;T!qfrDH)QoNf^lVDG#VMAuOT)8x2 z$M2BW1PJaCv7Kn&?)ZY5GojMJ2$(GOSp`bMdSzX6XdW3V>n4StS~P6ib>%R4IzZTG z@cMCu?UI`9mk1;1yGCCKv-izPuaGh-RU(X_Zv;b>)^qdQ>^?3LM$jd}kXyf(zPPOa zCW$Zt=HC*|K>yc;QXzz@1P)mGsqSRhfIEo3biyo8_0nrC4uB~pfPmB;R#)(x7;_iG z7XNgv(`QhB3J}(=7V(#wfm;*YnZOxv@zF1Kw0mk_uatNBoJ1Jmv+sJ@BaX33f0PFr z9y8ocv@oi_dvigbDPGtOHoGwExyo}SVcz*(b`=li%Lewo&Kvjo`90& zw()!N8l*P_$+ldg?#VYdd>b=KB1z5S!*;wIm0*vdmtHu2c-cyaM6kM9t?J*BRXNcs z4yPj*vbDRpM%3%yE_~-~i_o_v!U!MjXt<^Xj8*z$+%;4grDohswisXaSVT9d=Zm(;94jeE-B8;%wAfnm>ha-10K)7#l`+~oJISFyYh$7s_9&wCS z^h37g+8D|DDuxU8h!CjnV?$2uIM?~L4Z9^y;Ew*^K3{~x9b8W_Rjmk72|1+k2g{W8 zdSSnEIZviZgb}bnYzDM{0KQTIUUB5;Y~Zb*_Q2AE4cYh4>gkdGg)q4X2>ayz;WTZ9 z?@dUZ8DXEWCT_d-$Iovql?WsLJOAPs)i(tq)JEnVNckrY&QBQOqf?E6SOUf>txGYz ziG|u2S>O8UevrL-Qic~C^zBa|qru}oydH!7{^UmJ_ZJR9zptM8Mf?{H8YYm$6|YZR zQYShA_YZaBSQ^A$lI18U!a=D@$#BQ()#$=-xRI9(3z7r=1J`e=4z9e2h5)w37viAW%fu)I?)F#6#Y;jMPp$Dez%Lk`^9 z@{c*2eqgy|eI+ne!Yg8?OPT)TuzU_B5yuPs#`HuGt-CFt(G^>yI~qYq23Mp5OCq)3I<+ z%?KY%8)=}G)(bX7K~-wugqMGuJD|fExHicMin9#3Rh&K_zamGKp8<;oBdnH)>E1XC zHBb0n98T~DUVqd2MZrMChE&e{{OGVoEfP54W2f)pGF#8hJGTt&cvd2e0GsqP*l17^ zZf7W&dO(U0*f(JK?~($en-T1!Pn^2aKlZ1so>?=2FoK;Ph>`Yn{kES*-24)TL4dGY z+?*!}a2TQ_WdznZIm7Lu&eWJb&}bP!b;r7(a50zI^s5iuv8V9Np5oTovbB8u=CXHN z-GB?0M;G+H`t0xHp;#K2Nkuo>FsShylsOlhc{)$iQPDeVD;Ko8c|#%}5KZRQU5Ui!)c{n}N=kSK0C7o<&7VKmbhFPvH<`HY|O~dj_ECMe< z1fDi{ib2mKkP*dMYx+#UZY}pQBT%y_kmauj4c^MblYgikn6FwHUIZ6;XM8iU>y`Cj zvQY!HdD?_wjP>JY+7`_T(_Vp5tv95_<+6u{9GVM7SV#AB6RK8(ZD63TSOSLgtPkvH z1D&U-D<5ldpxY2okIbXnj{8v0fN}H;;?E-996&Ah-dA|;H^9Fcaf_4%eBg?K$t>n3 zJ~x00|MoWlA}z&I1(u@dPTf>f!uY}ZDp%JmhwEXC@X;N*c_m@cedhqBCE_aanZZ*e zl;qOJ@O@s`lrh3bKQ(xkfI*%GfHJzlrf2)lqzwNd*pZDX3u{l+TF}iy4W44fEq&$V zu?3E7i4?4Spy98hYb4l95uSOU4X)gJq(ruU)oFB-)D!w36=H3sJUni}u4$7Y;Rt^^ zr(Tz<5g^ufpTLGeQ+T>Vj~VU}3*_UK+r)j+4^qiH1v}ioo~AGgh+#?z7|s)~f>14( z=kk6R(;_cSfi2EwLq=B^_ZslDU8=ERkSE-n3-P}MO<{Fed@o|YUKeIcYfnyi`{Qx* zx=Mr*K6=PdUGxHb#4$_^#eJrcDw}y8?{p}%-o!Z)8T4tV%l-?Cf@bUO!TfD_&c7$} z?}d0Xf8$&i_OL?-D6Mvc<>-TX2%xlCrNQhfvT^atY_d6%x4n+ya1TsB#%7BlPV`(s zzhOJRx*w|VqIbI>##{-sVK~pN$nz6}r`S;MX+Nc9;;z{e`RdL2&$s*LUFhBW4W8nw zo-0irt#d39qH6UQ=f^d?=wpkRe!tJSE>%=W~c?9 z$*{B7zM*QP`XeQK7|s5pto(Wpm@yuokoU`}>zY1ZiITpd5U9X1>Iy^wJwCd~A03YKCU|1b|KJOQGJl%GA~80;q9 z(mKGJMxrWap64gGuhBVovqW~C-n;Inkn`M9?V$>Q|I$!hY;oV+^@CE_cAZ4lJtgP< z=`Q4!zJc()23+iLAJH$mEQ7%}{y#q+%KKVainAqL0}brd&5>-rJalf+dzS}gBuj)5 zKDx`0A+{Ur5yx1NB0;?mw@2{M7)HVN+QRmes!fnN4QzufQ^=a0Vqvrt;_v|%{U=CG(1J^&Zh@e(q>rfxo>{d^(0*u71> zL>S?t2MnFXLc$(#4Cmh(_|t=i&I14NqKm1WCHNw6@5QS%f1H0t=v)E@dA0{m^f)#r z44z^wkDj@%Our}a@SOiZ#1BGznCWJE;TPWi zU#7#1*{<90HF->_zykX>V(vLwM33=+q^w@ zO^pP$B#G!LV~U;zx4K0&8np-3fssFaP05c!oj$;s!nYjg1;Kt*M6Zt9Hy)M9)JvC3 zeZ1~8c)@nH-iG0x?TF2Oz7OQMK_asVYPR(^*81IVG{-k-tcc^;OzD z@k7bj-)Q#)iS*Atc=6*+t3c=XPzUo$Zo^o4>PxwKQodX-{7`)tq&ZV(r(SJ$|2E(m zNVdhKY{OW2>T9fd&K%qC(vd5#Lwb;OVsHJGlfMU^Zy0)t)1H{xE$hBr1(P%SW=f0uAnm}0bZ+D={YH7XGdwo)uWO527f4Jqv7@Q?b^fWUzrYTqnVx7K(0g5Y zP+!i?6JvDN;esg&0Tv$H3~(?h{qSZHytQKY_2Qom}3j9 zz$2F2TDWCcL6BJ6)K=@A`m25;a0P4hrku0O^Zg+9-C&1+qh{_|nF$-Ion7CMR;;qTaxvh!2UHN7|=zLr>jyzzs1XCyk+U@RiNLx}6*3AZMZTCL?q z^|pK(q^xaD>pJd@AsdfD89jR6Pa|vY#W~H!(}uA|gkG9A?+4ziIPRm>10kK5RB1-+ z(h19e=TJjW;ddJbdBy@tKk%m+h&R_=coi+C-Nfzk-c;b(Sm#+(!Hi)z&o;=|5zNzv z-x}7v8Be-3snVnM2gq|oFi#tX^K6bhTNpf{RucIA2ctAqMIusU!;ZHmAkR#LX9*bO zSr$+lUPh%8f_d_y4kT%Z+G^c^CyW@F2}~DUZ5YlIe=34P8i@WBIvDsL*tO~3ppI1x zPZNgo#9w@%knLD`?)m(3=|*9H#1pyP{#tztyMvy#>Z}dJdE&if`a&?zipTzWV(+|i z5|KarJly|VAK)1iY`YDEJRbyaLX6&#^TrJ<`rVfQO`RLv1ef4PqT}G>8QzKX`JNze$OI=SrI@(*5*m&ucN_8`b!jE!nTeNO)OnMPw z2VCj=(`(WoiFBAcH*V2fS%^(SvB`#5;qlv#JRB2}2Wy~zV@DX&uNLJ&8-{!EBCvz% z1AHQ;QjhUfBiv1FnPTarv2~KR{`4%&#EdASlh`AUVIusv!eU*=D#AU|3%BbmVjhtX zK3%#q%(ILrLJWJvF-(m11Pt85YBGFQ4`21V(~3)ajQ~w#L7WKgI*cwg2Zs$KgkasP zX>b=jrq}T{LUHG>;|--V1;8_~{}kP1!ywNB;AE5`R{l z&p>J;c-kp_vPGx77h{7|s*FpQO(P^PH&FjBl_4(z2HaTnFZ=xk5Ngl#xl_}f6{g=Rs0^>sD%e!T?lj+)U%h|C_$M2KD_hp9 zbiPNS2VChyjQMh@4TG-KdAgA2$Y7o`2aN7;`UCi~S--h`W)|?A9n8~);XL(v<;-B7 zE9PJJ_LE^fF1RgCfvp82ipcTV zBaUGr=o-{(EvjVhzA2g0TGmN{#cu7bEAy&fKMZcMMXe3Pc}_>3uNpkXEc)c;6$z;X zu6X@AVD9;*t(p`y5>{>>t`z(=Ln4nAoN@g$r3Q=y!xPwh#wRPq-seB~K5iFb^Y_8U zuFt!_udatEx{mJxjoF zJ(nWSw+x=b_7Bfp`S8w;qY?ox4|LCn1fHcJLM_A7hT%L*1C)j$-W)TX=O`y5N;A?wf& z>Dc5O&JfN!n0vEj-^4lzWMNfbTD@N$1I7PDj5$@YVHi(8ZaoTX>WUX}Gu+~#-=$ky zvW|lCjKDID-t+numayO+U@(qHp$Q;Q-eIoyV6-u(XnYX Date: Sun, 17 Jan 2021 17:01:52 -0800 Subject: [PATCH 12/43] Cleaned Up Imports This commit cleans up different imports and also deletes any out of place relics. --- perception/vis/TestTasks/BackgroundRemoval.py | 4 +- perception/vis/TestTasks/DepthMap.py | 7 +- perception/vis/TestTasks/RBD.py | 6 +- tasks/slot_machine/slot_machine_test.py | 144 ------------------ 4 files changed, 6 insertions(+), 155 deletions(-) delete mode 100644 tasks/slot_machine/slot_machine_test.py diff --git a/perception/vis/TestTasks/BackgroundRemoval.py b/perception/vis/TestTasks/BackgroundRemoval.py index 1a84a43..eef37fa 100644 --- a/perception/vis/TestTasks/BackgroundRemoval.py +++ b/perception/vis/TestTasks/BackgroundRemoval.py @@ -1,8 +1,8 @@ import cv2 as cv import numpy as np -from TaskPerceiver import TaskPerceiver +from perception.tasks.TaskPerceiver import TaskPerceiver from typing import Dict -from .dark_channel.handler import process_frame as dark_channel +from perception.misc.dark_channel.handler import process_frame as dark_channel class BackgroundRemoval(TaskPerceiver): diff --git a/perception/vis/TestTasks/DepthMap.py b/perception/vis/TestTasks/DepthMap.py index d442580..d1721f3 100644 --- a/perception/vis/TestTasks/DepthMap.py +++ b/perception/vis/TestTasks/DepthMap.py @@ -5,8 +5,7 @@ import matplotlib.ticker as ticker from matplotlib.figure import Figure from typing import Dict -from .combinedFilterDepthMap import init_combined_filter -from TaskPerceiver import TaskPerceiver +from perception.tasks.TaskPerceiver import TaskPerceiver def number_to_integral(number): return int(np.ceil(number)) @@ -104,10 +103,6 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): self.counter += 1 # PCA Experimentation stack = np.dstack((frame, t)).astype(np.uint8) - combined_filter = init_combined_filter() - depth_combined_pca = combined_filter(stack) - - pca = combined_filter(frame) return depth_map, [frame] diff --git a/perception/vis/TestTasks/RBD.py b/perception/vis/TestTasks/RBD.py index 1ca93f6..dac0a5c 100644 --- a/perception/vis/TestTasks/RBD.py +++ b/perception/vis/TestTasks/RBD.py @@ -1,6 +1,6 @@ -from TaskPerceiver import TaskPerceiver -from .saliency_mbd import get_saliency_mbd -from .binarise import binarise_saliency_map +from perception.tasks.TaskPerceiver import TaskPerceiver +from perception.vis.TestTasks.saliency_mbd import get_saliency_mbd +from perception.vis.TestTasks.binarise import binarise_saliency_map import numpy as np from typing import Dict diff --git a/tasks/slot_machine/slot_machine_test.py b/tasks/slot_machine/slot_machine_test.py deleted file mode 100644 index ce1f8c3..0000000 --- a/tasks/slot_machine/slot_machine_test.py +++ /dev/null @@ -1,144 +0,0 @@ -import numpy as np -import cv2 as cv -from utils import * - -def get_colors(frame, contour, x,y): - shaped = np.float32(frame.reshape(-1,3)) - x_curr = x[0] - y_curr = y[0] - # changed = [] - # for shape in shaped: - # if (cv.pointPolygonTest(contour,(x_curr,y_curr),False) >= 0): - # changed.append(shape) - # x_curr+=1 - # if(x_curr-1 == x[1]): - # # print(y_curr) - # x_curr = x[0] - # y_curr+=1 - # changed = np.float32(np.array(changed)) - # shaped = [shape for shape in shaped if cv.pointPolygonTest(contour,shape,False) >= 0] - n_colors = 2 - # print(changed,shaped) - criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 200, .1) - flags = cv.KMEANS_RANDOM_CENTERS - # print(len(shaped)-len(changed)) - # try: - # _, labels, palette = cv.kmeans(changed, n_colors, None, criteria, 10, flags) - # except: - _, labels, palette = cv.kmeans(shaped, n_colors, None, criteria, 10, flags) - - _, counts = np.unique(labels, return_counts=True) - ret = tuple(palette[np.argmax(counts)]) - ret = ( int (ret [ 0 ]), int (ret [ 1 ]), int (ret [ 2 ])) - # print(ret) - return ret - -def resize_frame(frame,ratio = 0.4): - return cv.resize(frame,(int(frame.shape[1]*ratio),int(frame.shape[0]*ratio))) - -cap = cv.VideoCapture("./water_spinner.MP4") -while not cap.isOpened(): - cap = cv.VideoCapture("./water_spinner.MP4") - cv.waitKey(1000) - print ("Wait for the header") - -while(True): - # Capture frame-by-frame - ret, frame = cap.read() - if ret: - frame = resize_frame(frame) - orig = frame - - bw_frame = cv.cvtColor(frame,cv.COLOR_RGB2GRAY) - high_thresh, thresh_im = cv.threshold((bw_frame), 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU) - # cv.imshow('thres',thresh_im) - lowThresh = 0.5*high_thresh - # print(high_thresh, lowThresh) - R,G,B = cv.split(frame) - # smooth = cv.bilateralFilter(frame,10,25,51) - smooth = cv.blur(frame,(2,2)) - # cv.imshow('test',smooth) - - # GENERATE CANNY EDGES - canny = cv.Canny(smooth, 100, high_thresh) - - sigma = 0.6 - v = np.median(smooth) - lower = int(max(0, (1.0 - sigma) * v)) - upper = int(min(255, (1.0 + sigma) * v)) - # print(lower, upper) - # canny = cv.Canny(smooth, lower, upper) - #TODO: ADD TO RET FRAMES - # cv.imshow('canny_new',canny) - - ## FIND CONTOURS - # _, contours, _ = cv.findContours(canny, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) - _, contours, _ = cv.findContours(canny, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) - outer_shell = np.zeros(frame.shape, np.uint8) - #keep only contours of more or less correct area and perimeter - cv.drawContours(outer_shell,contours,-1,(255,255,0),1) - cv.imshow('shell',outer_shell) - - w, h,c = frame.shape - blank = np.zeros((w, h)).astype(np.uint8) - cv.drawContours(blank, contours, -1, 1, 1) - blank = cv.morphologyEx(blank, cv.MORPH_CLOSE, np.ones((3, 3), np.uint8)) - _, contours, _ = cv.findContours(blank, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) - mask = np.zeros(frame.shape, np.uint8) - #keep only contours of more or less correct area and perimeter - contours = [c for c in contours if 100 < cv.contourArea(c) < 800] - cv.drawContours(mask,contours,-1,(255,255,0),1) - for i,c in enumerate(contours): - # mask = np.zeros(frame.shape, np.uint8) - # cv.drawContours(frame, c, -1,(0,0,255),1) - x,y,w,h = cv.boundingRect(c) # offsets - with this you get 'mask' - cimg = np.zeros_like(smooth) - # cv.imshow('cutted contour',frame[y:y+h,x:x+w]) - pts = cimg - # print(frame[c[1][0]]) - # arr = [] - # for v in c: - # try: - # arr.append(frame[v[0]]) - # except: - # pass - # arr = np.array(arr) - # np.array([frame[v[0]] for v in c]) - # get_colors(frame[y:y+h,x:x+w]) - # if 0.4 <= h/w <= 1.3 and 10 < len(cv.approxPolyDP(c, 0.01 * cv.arcLength(c, True), True)) and (cv.contourArea(c)/cv.arcLength(c, True)) > 0.5: - cv.rectangle(frame,(x,y),(x+w,y+h),get_colors(smooth[y:y+h,x:x+w],c,(y,y+h),(x,x+w)),2) - cv.imshow('res',frame) - # cv.imshow('eql',eql) - - # MASK TO SEE EDGES - - hulls = [] - usec = [] - for c in contours: - x,y,w,h = cv.boundingRect(c) - # if 10 < len(cv.approxPolyDP(c, 0.01 * cv.arcLength(c, True), True)) and (cv.contourArea(c)/cv.arcLength(c, True)) > 0.5: - hull = cv.convexHull(c) - # if cv.contourArea(hull)/cv.contourArea(c) > 0.8: - hulls.append(hull) - # cv.fillPoly(thresh_im, pts=[c], color=0) - usec.append(c) - # cv.drawContours(mask, c, -1, (0,255,0),1) - # top = sorted(list(zip(hulls,usec)),key= lambda h: cv.contourArea(h[0]) - cv.contourArea(h[1])) - # print(top) - # arr = np.array(top) - cv.drawContours(mask,hulls,-1,(255,0,0),1) - cv.drawContours(mask,usec,-1,(0,255,0),1) - cv.imshow('cont',mask) - - - # cv.imshow('orig',orig) - # cv.imshow('frame',frame) - if cv.waitKey(1) & 0xFF == ord('q'): - break - if cv.waitKey(32) == ord(' '): - while(not cv.waitKey(32) == ord(' ')): - continue - -# When everything done, release the capture -cap.release() -cv.destroyAllWindows() \ No newline at end of file From 2f735a548972ac97347c4f55c0b1533e53a82c78 Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sun, 24 Jan 2021 17:16:29 -0800 Subject: [PATCH 13/43] switch to knn based background algo --- .gitignore | 1 + perception/vis/TestTasks/BackgroundRemoval.py | 7 ++++++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index ae9b556..a975e57 100644 --- a/.gitignore +++ b/.gitignore @@ -18,5 +18,6 @@ __pycache__/ # IDE files .idea .vs_code/ +.vscode/ data/ diff --git a/perception/vis/TestTasks/BackgroundRemoval.py b/perception/vis/TestTasks/BackgroundRemoval.py index eef37fa..2280bdf 100644 --- a/perception/vis/TestTasks/BackgroundRemoval.py +++ b/perception/vis/TestTasks/BackgroundRemoval.py @@ -10,6 +10,7 @@ class BackgroundRemoval(TaskPerceiver): def __init__(self, **kwargs): super().__init__(blur = ((0, 10), 2), lamda = ((0,10),1)) self.prev_frame = None + self.knn = cv.createBackgroundSubtractorKNN() def gen_lamda_frame(self, frame, lamda): return (frame*lamda).astype(np.uint8) @@ -23,7 +24,7 @@ def calculate_blur(self, frame, lamda): self.prev_frame = cv.add(self.gen_lamda_frame(self.prev_frame,1-lamda), self.gen_lamda_frame(frame,lamda)) return self.prev_frame - def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + def analyze_old(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): # print(frame.shape) blur = frame # self.calculate_blur(frame,slider_vals["lamda"]/10) @@ -39,6 +40,10 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): # cv.fastNlMeansDenoising(no_blur, temp, 10,10, 7, 21) # print(blur.shape, dark.shape, otsu_dark.shape, clh.shape, no_blur.shape) return otsu_dark, [otsu_dark, clh, no_blur, blur, dark, frame, other, other_dark, other_otsu] + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + knn = self.knn.apply(frame) + return knn, [frame, knn] def threshold(self, frame, x = 0, y =255, clh = False): gray = cv.cvtColor(frame,cv.COLOR_BGR2GRAY) From 3b6e4bb22176e3bb05d7bde5560cf6ae220aeb39 Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sat, 30 Jan 2021 15:48:52 -0800 Subject: [PATCH 14/43] Added MBD --- .../segmentation/saliency_detection/MBD.py | 19 +++++++++++++ .../saliency_detection}/saliency_mbd.py | 4 +-- perception/vis/TestTasks/RBD.py | 12 -------- perception/vis/TestTasks/binarise.py | 28 ------------------- perception/vis/vis.py | 6 ++-- 5 files changed, 24 insertions(+), 45 deletions(-) create mode 100644 perception/tasks/segmentation/saliency_detection/MBD.py rename perception/{vis/TestTasks => tasks/segmentation/saliency_detection}/saliency_mbd.py (98%) delete mode 100644 perception/vis/TestTasks/RBD.py delete mode 100644 perception/vis/TestTasks/binarise.py diff --git a/perception/tasks/segmentation/saliency_detection/MBD.py b/perception/tasks/segmentation/saliency_detection/MBD.py new file mode 100644 index 0000000..510006c --- /dev/null +++ b/perception/tasks/segmentation/saliency_detection/MBD.py @@ -0,0 +1,19 @@ +from perception.tasks.TaskPerceiver import TaskPerceiver +from perception.tasks.segmentation.saliency_detection.saliency_mbd import get_saliency_mbd +import numpy as np +import cv2 as cv +from typing import Dict + +class MBD(TaskPerceiver): + + def __init__(self, **kwargs): + super().__init__(lower_bound=((0,255), 10)) + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + width = int(frame.shape[1] * 0.7) + height = int(frame.shape[0] * 0.7) + dsize = (width, height) + frame = cv.resize(frame, dsize) + mbd = get_saliency_mbd(frame).astype('uint8') + ret3,th3 = cv.threshold(mbd,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU) + return th3, [frame, mbd, th3] diff --git a/perception/vis/TestTasks/saliency_mbd.py b/perception/tasks/segmentation/saliency_detection/saliency_mbd.py similarity index 98% rename from perception/vis/TestTasks/saliency_mbd.py rename to perception/tasks/segmentation/saliency_detection/saliency_mbd.py index 42a8a51..c5c4a52 100644 --- a/perception/vis/TestTasks/saliency_mbd.py +++ b/perception/tasks/segmentation/saliency_detection/saliency_mbd.py @@ -2,7 +2,6 @@ import sys import operator import networkx as nx -#import matplotlib.pyplot as plt import numpy as np import scipy.spatial.distance import scipy.signal @@ -11,7 +10,6 @@ from skimage.segmentation import slic from skimage.util import img_as_float from scipy.optimize import minimize -#import pdb def raster_scan(img,L,U,D): n_rows = len(img) @@ -112,7 +110,7 @@ def get_saliency_mbd(img,method='b'): # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS img_mean = np.mean(img,axis=(2)) - sal = mbd(img_mean,3) + sal = mbd(img_mean,2) if method == 'b': # get the background map diff --git a/perception/vis/TestTasks/RBD.py b/perception/vis/TestTasks/RBD.py deleted file mode 100644 index dac0a5c..0000000 --- a/perception/vis/TestTasks/RBD.py +++ /dev/null @@ -1,12 +0,0 @@ -from perception.tasks.TaskPerceiver import TaskPerceiver -from perception.vis.TestTasks.saliency_mbd import get_saliency_mbd -from perception.vis.TestTasks.binarise import binarise_saliency_map -import numpy as np -from typing import Dict - -class RBD(TaskPerceiver): - - def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): - mbd = get_saliency_mbd(frame).astype('uint8') - binary_sal = binarise_saliency_map(mbd,method='adaptive') - return binary_sal, [frame, mbd, 255 * binary_sal.astype('uint8')] diff --git a/perception/vis/TestTasks/binarise.py b/perception/vis/TestTasks/binarise.py deleted file mode 100644 index ae77506..0000000 --- a/perception/vis/TestTasks/binarise.py +++ /dev/null @@ -1,28 +0,0 @@ -import numpy as np - -def binarise_saliency_map(saliency_map,method='adaptive',threshold=0.5): - - # check if input is a numpy array - if type(saliency_map).__module__ != np.__name__: - print('Expected numpy array') - return None - - #check if input is 2D - if len(saliency_map.shape) != 2: - print('Saliency map must be 2D') - return None - - if method == 'fixed': - return (saliency_map > threshold) - - elif method == 'adaptive': - adaptive_threshold = 2.0 * saliency_map.mean() - return (saliency_map > adaptive_threshold) - - elif method == 'clustering': - print('Not yet implemented') - return None - - else: - print("Method must be one of fixed, adaptive or clustering") - return None diff --git a/perception/vis/vis.py b/perception/vis/vis.py index ee6a12b..99b353a 100644 --- a/perception/vis/vis.py +++ b/perception/vis/vis.py @@ -52,8 +52,10 @@ def run(data_sources, algorithm, save_video=False): def profile(*args, stats='all'): - with cProfile.Profile() as pr: - run(*args) + pr = cProfile.Profile() + pr.enable() + run(*args) + pr.disable() if stats == 'all': pr.print_stats() else: From 96c2d14238a24795f99254aad2764d8ce97a084a Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sat, 30 Jan 2021 15:49:06 -0800 Subject: [PATCH 15/43] Added MBD to Code --- perception/__init__.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/perception/__init__.py b/perception/__init__.py index 74b1032..3ffbb71 100644 --- a/perception/__init__.py +++ b/perception/__init__.py @@ -3,6 +3,7 @@ import perception.tasks.gate.GateSegmentationAlgoA as GateSegA import perception.tasks.gate.GateSegmentationAlgoB as GateSegB import perception.tasks.gate.GateSegmentationAlgoC as GateSegC +import perception.tasks.segmentation.saliency_detection.MBD as MBD # import perception.tasks as tasks ALGOS = { @@ -10,5 +11,6 @@ 'gateseg': GateSeg.GateCenterAlgo, 'gatesegA': GateSegA.GateSegmentationAlgoA, 'gatesegB': GateSegB.GateSegmentationAlgoB, - 'gatesegC': GateSegC.GateSegmentationAlgoC + 'gatesegC': GateSegC.GateSegmentationAlgoC, + 'MBD': MBD.MBD } From 27c705aade3757c9794665d3d0714eea279138ad Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sat, 30 Jan 2021 19:19:35 -0800 Subject: [PATCH 16/43] Cythonized the saliency_mbd --- .../saliency_mbd.o | Bin 0 -> 683332 bytes .../saliency_mbd.o | Bin 0 -> 127964 bytes .../saliency_detection/saliency_mbd.c | 13157 ++++++++++++++++ .../saliency_detection/saliency_mbd.html | 3766 +++++ .../saliency_detection/saliency_mbd.py | 236 - .../saliency_detection/saliency_mbd.pyx | 250 + .../segmentation/saliency_detection/setup.py | 8 + 7 files changed, 17181 insertions(+), 236 deletions(-) create mode 100644 perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.7/saliency_mbd.o create mode 100644 perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.8/saliency_mbd.o create mode 100644 perception/tasks/segmentation/saliency_detection/saliency_mbd.c create mode 100644 perception/tasks/segmentation/saliency_detection/saliency_mbd.html delete mode 100644 perception/tasks/segmentation/saliency_detection/saliency_mbd.py create mode 100644 perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx create mode 100644 perception/tasks/segmentation/saliency_detection/setup.py diff --git a/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.7/saliency_mbd.o b/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.7/saliency_mbd.o new file mode 100644 index 0000000000000000000000000000000000000000..aa514436db8e242d734dd05c2388b308c45cdecf GIT binary patch literal 683332 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
}t(5R+ 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 literal 0 HcmV?d00001 diff --git a/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.8/saliency_mbd.o b/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.8/saliency_mbd.o new file mode 100644 index 0000000000000000000000000000000000000000..2851c4937bbcf79004245d63d6abdfb461ef46fe GIT binary patch literal 127964 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 +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" +#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__saliency_mbd +#define __PYX_HAVE_API__saliency_mbd +/* Early includes */ +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "saliency_mbd.pyx", + "__init__.pxd", + "type.pxd", +}; +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":775 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":789 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":807 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":810 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + + +/*--- Type declarations ---*/ + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd; + +/* "saliency_mbd.pyx":132 + * + * @cython.boundscheck(False) + * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< + * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + * img_mean = np.mean(img,axis=(2)) + */ +struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd { + int __pyx_n; + PyObject *method; +}; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* BufferGetAndValidate.proto */ +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ + ((obj == Py_None || obj == NULL) ?\ + (__Pyx_ZeroBuffer(buf), 0) :\ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; +static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* SetItemInt.proto */ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* None.proto */ +static CYTHON_INLINE long __Pyx_mod_long(long, long); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* PyFloatBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyFloat_SubtractObjC(op1, op2, floatval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +/* PyIntFromDouble.proto */ +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value); +#else +#define __Pyx_PyInt_FromDouble(value) PyLong_FromDouble(value) +#endif + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* PyFloatBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyFloat_DivideObjC(op1, op2, floatval, inplace, zerodivision_check)\ + ((inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2))) + #endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_SubtractCObj(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto +#define __PYX_HAVE_RT_ImportType_proto +enum __Pyx_ImportType_CheckSize { + __Pyx_ImportType_CheckSize_Error = 0, + __Pyx_ImportType_CheckSize_Warn = 1, + __Pyx_ImportType_CheckSize_Ignore = 2 +}; +static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value); + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'libc.math' */ + +/* Module declarations from 'saliency_mbd' */ +static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *, PyArrayObject *, PyArrayObject *, PyArrayObject *); /*proto*/ +static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *, PyArrayObject *, PyArrayObject *, PyArrayObject *); /*proto*/ +static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *, int); /*proto*/ +static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd *__pyx_optional_args); /*proto*/ +static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; +#define __Pyx_MODULE_NAME "saliency_mbd" +extern int __pyx_module_is_main_saliency_mbd; +int __pyx_module_is_main_saliency_mbd = 0; + +/* Implementation of 'saliency_mbd' */ +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_RuntimeError; +static PyObject *__pyx_builtin_ImportError; +static const char __pyx_k_T[] = "T"; +static const char __pyx_k_b[] = "b"; +static const char __pyx_k_f[] = "f"; +static const char __pyx_k_x[] = "x"; +static const char __pyx_k_VI[] = "VI"; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_cov[] = "cov"; +static const char __pyx_k_img[] = "img"; +static const char __pyx_k_inv[] = "inv"; +static const char __pyx_k_max[] = "max"; +static const char __pyx_k_sys[] = "sys"; +static const char __pyx_k_axis[] = "axis"; +static const char __pyx_k_copy[] = "copy"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_mean[] = "mean"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_sqrt[] = "sqrt"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_cdist[] = "cdist"; +static const char __pyx_k_color[] = "color"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_power[] = "power"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_scipy[] = "scipy"; +static const char __pyx_k_shape[] = "shape"; +static const char __pyx_k_zeros[] = "zeros"; +static const char __pyx_k_arange[] = "arange"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_linalg[] = "linalg"; +static const char __pyx_k_method[] = "method"; +static const char __pyx_k_maximum[] = "maximum"; +static const char __pyx_k_reshape[] = "reshape"; +static const char __pyx_k_rgb2lab[] = "rgb2lab"; +static const char __pyx_k_skimage[] = "skimage"; +static const char __pyx_k_spatial[] = "spatial"; +static const char __pyx_k_distance[] = "distance"; +static const char __pyx_k_meshgrid[] = "meshgrid"; +static const char __pyx_k_minimize[] = "minimize"; +static const char __pyx_k_full_like[] = "full_like"; +static const char __pyx_k_vectorize[] = "vectorize"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_skimage_io[] = "skimage.io"; +static const char __pyx_k_ImportError[] = "ImportError"; +static const char __pyx_k_mahalanobis[] = "mahalanobis"; +static const char __pyx_k_RuntimeError[] = "RuntimeError"; +static const char __pyx_k_img_as_float[] = "img_as_float"; +static const char __pyx_k_saliency_mbd[] = "saliency_mbd"; +static const char __pyx_k_skimage_util[] = "skimage.util"; +static const char __pyx_k_scipy_optimize[] = "scipy.optimize"; +static const char __pyx_k_saliency_mbd_pyx[] = "saliency_mbd.pyx"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_scipy_spatial_distance[] = "scipy.spatial.distance"; +static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; +static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_n_s_ImportError; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_T; +static PyObject *__pyx_n_s_VI; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_arange; +static PyObject *__pyx_n_s_axis; +static PyObject *__pyx_n_s_b; +static PyObject *__pyx_n_s_cdist; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_color; +static PyObject *__pyx_n_s_copy; +static PyObject *__pyx_n_s_cov; +static PyObject *__pyx_n_s_distance; +static PyObject *__pyx_n_s_f; +static PyObject *__pyx_n_s_full_like; +static PyObject *__pyx_n_s_img; +static PyObject *__pyx_n_s_img_as_float; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_inv; +static PyObject *__pyx_n_s_linalg; +static PyObject *__pyx_n_s_mahalanobis; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_max; +static PyObject *__pyx_n_s_maximum; +static PyObject *__pyx_n_s_mean; +static PyObject *__pyx_n_s_meshgrid; +static PyObject *__pyx_n_s_method; +static PyObject *__pyx_n_s_minimize; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; +static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_n_s_power; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_reshape; +static PyObject *__pyx_n_s_rgb2lab; +static PyObject *__pyx_n_s_saliency_mbd; +static PyObject *__pyx_kp_s_saliency_mbd_pyx; +static PyObject *__pyx_n_s_scipy; +static PyObject *__pyx_n_s_scipy_optimize; +static PyObject *__pyx_n_s_scipy_spatial_distance; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_skimage; +static PyObject *__pyx_n_s_skimage_io; +static PyObject *__pyx_n_s_skimage_util; +static PyObject *__pyx_n_s_spatial; +static PyObject *__pyx_n_s_sqrt; +static PyObject *__pyx_n_s_sys; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_n_s_vectorize; +static PyObject *__pyx_n_s_x; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_float_0_5; +static PyObject *__pyx_float_2_0; +static PyObject *__pyx_float_255_0; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; +static PyObject *__pyx_int_10000000; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_slice_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__14; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_codeobj__16; +/* Late includes */ + +/* "saliency_mbd.pyx":15 + * + * @cython.boundscheck(False) + * cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): # <<<<<<<<<<<<<< + * cdef int n_rows + * cdef int n_cols + */ + +static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) { + int __pyx_v_n_rows; + int __pyx_v_n_cols; + int __pyx_v_x; + int __pyx_v_y; + double __pyx_v_ix; + double __pyx_v_d; + double __pyx_v_u1; + double __pyx_v_l1; + double __pyx_v_u2; + double __pyx_v_l2; + double __pyx_v_b1; + double __pyx_v_b2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_D; + __Pyx_Buffer __pyx_pybuffer_D; + __Pyx_LocalBuf_ND __pyx_pybuffernd_L; + __Pyx_Buffer __pyx_pybuffer_L; + __Pyx_LocalBuf_ND __pyx_pybuffernd_U; + __Pyx_Buffer __pyx_pybuffer_U; + __Pyx_LocalBuf_ND __pyx_pybuffernd_img; + __Pyx_Buffer __pyx_pybuffer_img; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + long __pyx_t_3; + long __pyx_t_4; + int __pyx_t_5; + long __pyx_t_6; + long __pyx_t_7; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + double __pyx_t_10; + long __pyx_t_11; + double __pyx_t_12; + double __pyx_t_13; + double __pyx_t_14; + int __pyx_t_15; + int __pyx_t_16; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("raster_scan", 0); + __pyx_pybuffer_img.pybuffer.buf = NULL; + __pyx_pybuffer_img.refcount = 0; + __pyx_pybuffernd_img.data = NULL; + __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img; + __pyx_pybuffer_L.pybuffer.buf = NULL; + __pyx_pybuffer_L.refcount = 0; + __pyx_pybuffernd_L.data = NULL; + __pyx_pybuffernd_L.rcbuffer = &__pyx_pybuffer_L; + __pyx_pybuffer_U.pybuffer.buf = NULL; + __pyx_pybuffer_U.refcount = 0; + __pyx_pybuffernd_U.data = NULL; + __pyx_pybuffernd_U.rcbuffer = &__pyx_pybuffer_U; + __pyx_pybuffer_D.pybuffer.buf = NULL; + __pyx_pybuffer_D.refcount = 0; + __pyx_pybuffernd_D.data = NULL; + __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + } + __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + } + __pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + } + __pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + } + __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; + + /* "saliency_mbd.pyx":19 + * cdef int n_cols + * + * n_rows = len(img) # <<<<<<<<<<<<<< + * n_cols = len(img[0]) + * + */ + __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_img)); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) + __pyx_v_n_rows = __pyx_t_1; + + /* "saliency_mbd.pyx":20 + * + * n_rows = len(img) + * n_cols = len(img[0]) # <<<<<<<<<<<<<< + * + * cdef int x + */ + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_n_cols = __pyx_t_1; + + /* "saliency_mbd.pyx":33 + * cdef double b2 + * + * for x in range(1,n_rows - 1): # <<<<<<<<<<<<<< + * for y in range(1,n_cols - 1): + * ix = img[x][y] + */ + __pyx_t_3 = (__pyx_v_n_rows - 1); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 1; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_x = __pyx_t_5; + + /* "saliency_mbd.pyx":34 + * + * for x in range(1,n_rows - 1): + * for y in range(1,n_cols - 1): # <<<<<<<<<<<<<< + * ix = img[x][y] + * d = D[x][y] + */ + __pyx_t_6 = (__pyx_v_n_cols - 1); + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 1; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_v_y = __pyx_t_8; + + /* "saliency_mbd.pyx":35 + * for x in range(1,n_rows - 1): + * for y in range(1,n_cols - 1): + * ix = img[x][y] # <<<<<<<<<<<<<< + * d = D[x][y] + * + */ + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_ix = __pyx_t_10; + + /* "saliency_mbd.pyx":36 + * for y in range(1,n_cols - 1): + * ix = img[x][y] + * d = D[x][y] # <<<<<<<<<<<<<< + * + * u1 = U[x-1][y] + */ + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_d = __pyx_t_10; + + /* "saliency_mbd.pyx":38 + * d = D[x][y] + * + * u1 = U[x-1][y] # <<<<<<<<<<<<<< + * l1 = L[x-1][y] + * + */ + __pyx_t_11 = (__pyx_v_x - 1); + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_u1 = __pyx_t_10; + + /* "saliency_mbd.pyx":39 + * + * u1 = U[x-1][y] + * l1 = L[x-1][y] # <<<<<<<<<<<<<< + * + * u2 = U[x][y-1] + */ + __pyx_t_11 = (__pyx_v_x - 1); + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_l1 = __pyx_t_10; + + /* "saliency_mbd.pyx":41 + * l1 = L[x-1][y] + * + * u2 = U[x][y-1] # <<<<<<<<<<<<<< + * l2 = L[x][y-1] + * + */ + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = (__pyx_v_y - 1); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_u2 = __pyx_t_10; + + /* "saliency_mbd.pyx":42 + * + * u2 = U[x][y-1] + * l2 = L[x][y-1] # <<<<<<<<<<<<<< + * + * b1 = max(u1,ix) - min(l1,ix) + */ + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_11 = (__pyx_v_y - 1); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_l2 = __pyx_t_10; + + /* "saliency_mbd.pyx":44 + * l2 = L[x][y-1] + * + * b1 = max(u1,ix) - min(l1,ix) # <<<<<<<<<<<<<< + * b2 = max(u2,ix) - min(l2,ix) + * + */ + __pyx_t_10 = __pyx_v_ix; + __pyx_t_12 = __pyx_v_u1; + if (((__pyx_t_10 > __pyx_t_12) != 0)) { + __pyx_t_13 = __pyx_t_10; + } else { + __pyx_t_13 = __pyx_t_12; + } + __pyx_t_10 = __pyx_v_ix; + __pyx_t_12 = __pyx_v_l1; + if (((__pyx_t_10 < __pyx_t_12) != 0)) { + __pyx_t_14 = __pyx_t_10; + } else { + __pyx_t_14 = __pyx_t_12; + } + __pyx_v_b1 = (__pyx_t_13 - __pyx_t_14); + + /* "saliency_mbd.pyx":45 + * + * b1 = max(u1,ix) - min(l1,ix) + * b2 = max(u2,ix) - min(l2,ix) # <<<<<<<<<<<<<< + * + * if d <= b1 and d <= b2: + */ + __pyx_t_14 = __pyx_v_ix; + __pyx_t_13 = __pyx_v_u2; + if (((__pyx_t_14 > __pyx_t_13) != 0)) { + __pyx_t_10 = __pyx_t_14; + } else { + __pyx_t_10 = __pyx_t_13; + } + __pyx_t_14 = __pyx_v_ix; + __pyx_t_13 = __pyx_v_l2; + if (((__pyx_t_14 < __pyx_t_13) != 0)) { + __pyx_t_12 = __pyx_t_14; + } else { + __pyx_t_12 = __pyx_t_13; + } + __pyx_v_b2 = (__pyx_t_10 - __pyx_t_12); + + /* "saliency_mbd.pyx":47 + * b2 = max(u2,ix) - min(l2,ix) + * + * if d <= b1 and d <= b2: # <<<<<<<<<<<<<< + * continue + * elif b1 < d and b1 <= b2: + */ + __pyx_t_16 = ((__pyx_v_d <= __pyx_v_b1) != 0); + if (__pyx_t_16) { + } else { + __pyx_t_15 = __pyx_t_16; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_16 = ((__pyx_v_d <= __pyx_v_b2) != 0); + __pyx_t_15 = __pyx_t_16; + __pyx_L8_bool_binop_done:; + if (__pyx_t_15) { + + /* "saliency_mbd.pyx":48 + * + * if d <= b1 and d <= b2: + * continue # <<<<<<<<<<<<<< + * elif b1 < d and b1 <= b2: + * D[x][y] = b1 + */ + goto __pyx_L5_continue; + + /* "saliency_mbd.pyx":47 + * b2 = max(u2,ix) - min(l2,ix) + * + * if d <= b1 and d <= b2: # <<<<<<<<<<<<<< + * continue + * elif b1 < d and b1 <= b2: + */ + } + + /* "saliency_mbd.pyx":49 + * if d <= b1 and d <= b2: + * continue + * elif b1 < d and b1 <= b2: # <<<<<<<<<<<<<< + * D[x][y] = b1 + * U[x][y] = max(u1,ix) + */ + __pyx_t_16 = ((__pyx_v_b1 < __pyx_v_d) != 0); + if (__pyx_t_16) { + } else { + __pyx_t_15 = __pyx_t_16; + goto __pyx_L10_bool_binop_done; + } + __pyx_t_16 = ((__pyx_v_b1 <= __pyx_v_b2) != 0); + __pyx_t_15 = __pyx_t_16; + __pyx_L10_bool_binop_done:; + if (__pyx_t_15) { + + /* "saliency_mbd.pyx":50 + * continue + * elif b1 < d and b1 <= b2: + * D[x][y] = b1 # <<<<<<<<<<<<<< + * U[x][y] = max(u1,ix) + * L[x][y] = min(l1,ix) + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":51 + * elif b1 < d and b1 <= b2: + * D[x][y] = b1 + * U[x][y] = max(u1,ix) # <<<<<<<<<<<<<< + * L[x][y] = min(l1,ix) + * else: + */ + __pyx_t_12 = __pyx_v_ix; + __pyx_t_10 = __pyx_v_u1; + if (((__pyx_t_12 > __pyx_t_10) != 0)) { + __pyx_t_14 = __pyx_t_12; + } else { + __pyx_t_14 = __pyx_t_10; + } + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":52 + * D[x][y] = b1 + * U[x][y] = max(u1,ix) + * L[x][y] = min(l1,ix) # <<<<<<<<<<<<<< + * else: + * D[x][y] = b2 + */ + __pyx_t_14 = __pyx_v_ix; + __pyx_t_12 = __pyx_v_l1; + if (((__pyx_t_14 < __pyx_t_12) != 0)) { + __pyx_t_10 = __pyx_t_14; + } else { + __pyx_t_10 = __pyx_t_12; + } + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":49 + * if d <= b1 and d <= b2: + * continue + * elif b1 < d and b1 <= b2: # <<<<<<<<<<<<<< + * D[x][y] = b1 + * U[x][y] = max(u1,ix) + */ + goto __pyx_L7; + } + + /* "saliency_mbd.pyx":54 + * L[x][y] = min(l1,ix) + * else: + * D[x][y] = b2 # <<<<<<<<<<<<<< + * U[x][y] = max(u2,ix) + * L[x][y] = min(l2,ix) + */ + /*else*/ { + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":55 + * else: + * D[x][y] = b2 + * U[x][y] = max(u2,ix) # <<<<<<<<<<<<<< + * L[x][y] = min(l2,ix) + * + */ + __pyx_t_10 = __pyx_v_ix; + __pyx_t_14 = __pyx_v_u2; + if (((__pyx_t_10 > __pyx_t_14) != 0)) { + __pyx_t_12 = __pyx_t_10; + } else { + __pyx_t_12 = __pyx_t_14; + } + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":56 + * D[x][y] = b2 + * U[x][y] = max(u2,ix) + * L[x][y] = min(l2,ix) # <<<<<<<<<<<<<< + * + * return True + */ + __pyx_t_12 = __pyx_v_ix; + __pyx_t_10 = __pyx_v_l2; + if (((__pyx_t_12 < __pyx_t_10) != 0)) { + __pyx_t_14 = __pyx_t_12; + } else { + __pyx_t_14 = __pyx_t_10; + } + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L7:; + __pyx_L5_continue:; + } + } + + /* "saliency_mbd.pyx":58 + * L[x][y] = min(l2,ix) + * + * return True # <<<<<<<<<<<<<< + * + * @cython.boundscheck(False) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "saliency_mbd.pyx":15 + * + * @cython.boundscheck(False) + * cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): # <<<<<<<<<<<<<< + * cdef int n_rows + * cdef int n_cols + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_9); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("saliency_mbd.raster_scan", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "saliency_mbd.pyx":61 + * + * @cython.boundscheck(False) + * cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): # <<<<<<<<<<<<<< + * cdef int n_rows + * cdef int n_cols + */ + +static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) { + int __pyx_v_n_rows; + int __pyx_v_n_cols; + int __pyx_v_x; + int __pyx_v_y; + double __pyx_v_ix; + double __pyx_v_d; + double __pyx_v_u1; + double __pyx_v_l1; + double __pyx_v_u2; + double __pyx_v_l2; + double __pyx_v_b1; + double __pyx_v_b2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_D; + __Pyx_Buffer __pyx_pybuffer_D; + __Pyx_LocalBuf_ND __pyx_pybuffernd_L; + __Pyx_Buffer __pyx_pybuffer_L; + __Pyx_LocalBuf_ND __pyx_pybuffernd_U; + __Pyx_Buffer __pyx_pybuffer_U; + __Pyx_LocalBuf_ND __pyx_pybuffernd_img; + __Pyx_Buffer __pyx_pybuffer_img; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + double __pyx_t_6; + long __pyx_t_7; + double __pyx_t_8; + double __pyx_t_9; + double __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("raster_scan_inv", 0); + __pyx_pybuffer_img.pybuffer.buf = NULL; + __pyx_pybuffer_img.refcount = 0; + __pyx_pybuffernd_img.data = NULL; + __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img; + __pyx_pybuffer_L.pybuffer.buf = NULL; + __pyx_pybuffer_L.refcount = 0; + __pyx_pybuffernd_L.data = NULL; + __pyx_pybuffernd_L.rcbuffer = &__pyx_pybuffer_L; + __pyx_pybuffer_U.pybuffer.buf = NULL; + __pyx_pybuffer_U.refcount = 0; + __pyx_pybuffernd_U.data = NULL; + __pyx_pybuffernd_U.rcbuffer = &__pyx_pybuffer_U; + __pyx_pybuffer_D.pybuffer.buf = NULL; + __pyx_pybuffer_D.refcount = 0; + __pyx_pybuffernd_D.data = NULL; + __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) + } + __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) + } + __pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) + } + __pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) + } + __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; + + /* "saliency_mbd.pyx":65 + * cdef int n_cols + * + * n_rows = len(img) # <<<<<<<<<<<<<< + * n_cols = len(img[0]) + * + */ + __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_img)); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 65, __pyx_L1_error) + __pyx_v_n_rows = __pyx_t_1; + + /* "saliency_mbd.pyx":66 + * + * n_rows = len(img) + * n_cols = len(img[0]) # <<<<<<<<<<<<<< + * + * cdef int x + */ + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_n_cols = __pyx_t_1; + + /* "saliency_mbd.pyx":79 + * cdef double b2 + * + * for x in range(n_rows - 2,1,-1): # <<<<<<<<<<<<<< + * for y in range(n_cols - 2,1,-1): + * + */ + for (__pyx_t_3 = (__pyx_v_n_rows - 2); __pyx_t_3 > 1; __pyx_t_3-=1) { + __pyx_v_x = __pyx_t_3; + + /* "saliency_mbd.pyx":80 + * + * for x in range(n_rows - 2,1,-1): + * for y in range(n_cols - 2,1,-1): # <<<<<<<<<<<<<< + * + * ix = img[x][y] + */ + for (__pyx_t_4 = (__pyx_v_n_cols - 2); __pyx_t_4 > 1; __pyx_t_4-=1) { + __pyx_v_y = __pyx_t_4; + + /* "saliency_mbd.pyx":82 + * for y in range(n_cols - 2,1,-1): + * + * ix = img[x][y] # <<<<<<<<<<<<<< + * d = D[x][y] + * + */ + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_ix = __pyx_t_6; + + /* "saliency_mbd.pyx":83 + * + * ix = img[x][y] + * d = D[x][y] # <<<<<<<<<<<<<< + * + * u1 = U[x+1][y] + */ + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_d = __pyx_t_6; + + /* "saliency_mbd.pyx":85 + * d = D[x][y] + * + * u1 = U[x+1][y] # <<<<<<<<<<<<<< + * l1 = L[x+1][y] + * + */ + __pyx_t_7 = (__pyx_v_x + 1); + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_u1 = __pyx_t_6; + + /* "saliency_mbd.pyx":86 + * + * u1 = U[x+1][y] + * l1 = L[x+1][y] # <<<<<<<<<<<<<< + * + * u2 = U[x][y+1] + */ + __pyx_t_7 = (__pyx_v_x + 1); + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_l1 = __pyx_t_6; + + /* "saliency_mbd.pyx":88 + * l1 = L[x+1][y] + * + * u2 = U[x][y+1] # <<<<<<<<<<<<<< + * l2 = L[x][y+1] + * + */ + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = (__pyx_v_y + 1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_u2 = __pyx_t_6; + + /* "saliency_mbd.pyx":89 + * + * u2 = U[x][y+1] + * l2 = L[x][y+1] # <<<<<<<<<<<<<< + * + * b1 = max(u1,ix) - min(l1,ix) + */ + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = (__pyx_v_y + 1); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_l2 = __pyx_t_6; + + /* "saliency_mbd.pyx":91 + * l2 = L[x][y+1] + * + * b1 = max(u1,ix) - min(l1,ix) # <<<<<<<<<<<<<< + * b2 = max(u2,ix) - min(l2,ix) + * + */ + __pyx_t_6 = __pyx_v_ix; + __pyx_t_8 = __pyx_v_u1; + if (((__pyx_t_6 > __pyx_t_8) != 0)) { + __pyx_t_9 = __pyx_t_6; + } else { + __pyx_t_9 = __pyx_t_8; + } + __pyx_t_6 = __pyx_v_ix; + __pyx_t_8 = __pyx_v_l1; + if (((__pyx_t_6 < __pyx_t_8) != 0)) { + __pyx_t_10 = __pyx_t_6; + } else { + __pyx_t_10 = __pyx_t_8; + } + __pyx_v_b1 = (__pyx_t_9 - __pyx_t_10); + + /* "saliency_mbd.pyx":92 + * + * b1 = max(u1,ix) - min(l1,ix) + * b2 = max(u2,ix) - min(l2,ix) # <<<<<<<<<<<<<< + * + * if d <= b1 and d <= b2: + */ + __pyx_t_10 = __pyx_v_ix; + __pyx_t_9 = __pyx_v_u2; + if (((__pyx_t_10 > __pyx_t_9) != 0)) { + __pyx_t_6 = __pyx_t_10; + } else { + __pyx_t_6 = __pyx_t_9; + } + __pyx_t_10 = __pyx_v_ix; + __pyx_t_9 = __pyx_v_l2; + if (((__pyx_t_10 < __pyx_t_9) != 0)) { + __pyx_t_8 = __pyx_t_10; + } else { + __pyx_t_8 = __pyx_t_9; + } + __pyx_v_b2 = (__pyx_t_6 - __pyx_t_8); + + /* "saliency_mbd.pyx":94 + * b2 = max(u2,ix) - min(l2,ix) + * + * if d <= b1 and d <= b2: # <<<<<<<<<<<<<< + * continue + * elif b1 < d and b1 <= b2: + */ + __pyx_t_12 = ((__pyx_v_d <= __pyx_v_b1) != 0); + if (__pyx_t_12) { + } else { + __pyx_t_11 = __pyx_t_12; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_12 = ((__pyx_v_d <= __pyx_v_b2) != 0); + __pyx_t_11 = __pyx_t_12; + __pyx_L8_bool_binop_done:; + if (__pyx_t_11) { + + /* "saliency_mbd.pyx":95 + * + * if d <= b1 and d <= b2: + * continue # <<<<<<<<<<<<<< + * elif b1 < d and b1 <= b2: + * D[x][y] = b1 + */ + goto __pyx_L5_continue; + + /* "saliency_mbd.pyx":94 + * b2 = max(u2,ix) - min(l2,ix) + * + * if d <= b1 and d <= b2: # <<<<<<<<<<<<<< + * continue + * elif b1 < d and b1 <= b2: + */ + } + + /* "saliency_mbd.pyx":96 + * if d <= b1 and d <= b2: + * continue + * elif b1 < d and b1 <= b2: # <<<<<<<<<<<<<< + * D[x][y] = b1 + * U[x][y] = max(u1,ix) + */ + __pyx_t_12 = ((__pyx_v_b1 < __pyx_v_d) != 0); + if (__pyx_t_12) { + } else { + __pyx_t_11 = __pyx_t_12; + goto __pyx_L10_bool_binop_done; + } + __pyx_t_12 = ((__pyx_v_b1 <= __pyx_v_b2) != 0); + __pyx_t_11 = __pyx_t_12; + __pyx_L10_bool_binop_done:; + if (__pyx_t_11) { + + /* "saliency_mbd.pyx":97 + * continue + * elif b1 < d and b1 <= b2: + * D[x][y] = b1 # <<<<<<<<<<<<<< + * U[x][y] = max(u1,ix) + * L[x][y] = min(l1,ix) + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":98 + * elif b1 < d and b1 <= b2: + * D[x][y] = b1 + * U[x][y] = max(u1,ix) # <<<<<<<<<<<<<< + * L[x][y] = min(l1,ix) + * else: + */ + __pyx_t_8 = __pyx_v_ix; + __pyx_t_6 = __pyx_v_u1; + if (((__pyx_t_8 > __pyx_t_6) != 0)) { + __pyx_t_10 = __pyx_t_8; + } else { + __pyx_t_10 = __pyx_t_6; + } + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":99 + * D[x][y] = b1 + * U[x][y] = max(u1,ix) + * L[x][y] = min(l1,ix) # <<<<<<<<<<<<<< + * else: + * D[x][y] = b2 + */ + __pyx_t_10 = __pyx_v_ix; + __pyx_t_8 = __pyx_v_l1; + if (((__pyx_t_10 < __pyx_t_8) != 0)) { + __pyx_t_6 = __pyx_t_10; + } else { + __pyx_t_6 = __pyx_t_8; + } + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":96 + * if d <= b1 and d <= b2: + * continue + * elif b1 < d and b1 <= b2: # <<<<<<<<<<<<<< + * D[x][y] = b1 + * U[x][y] = max(u1,ix) + */ + goto __pyx_L7; + } + + /* "saliency_mbd.pyx":101 + * L[x][y] = min(l1,ix) + * else: + * D[x][y] = b2 # <<<<<<<<<<<<<< + * U[x][y] = max(u2,ix) + * L[x][y] = min(l2,ix) + */ + /*else*/ { + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":102 + * else: + * D[x][y] = b2 + * U[x][y] = max(u2,ix) # <<<<<<<<<<<<<< + * L[x][y] = min(l2,ix) + * + */ + __pyx_t_6 = __pyx_v_ix; + __pyx_t_10 = __pyx_v_u2; + if (((__pyx_t_6 > __pyx_t_10) != 0)) { + __pyx_t_8 = __pyx_t_6; + } else { + __pyx_t_8 = __pyx_t_10; + } + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":103 + * D[x][y] = b2 + * U[x][y] = max(u2,ix) + * L[x][y] = min(l2,ix) # <<<<<<<<<<<<<< + * + * return True + */ + __pyx_t_8 = __pyx_v_ix; + __pyx_t_6 = __pyx_v_l2; + if (((__pyx_t_8 < __pyx_t_6) != 0)) { + __pyx_t_10 = __pyx_t_8; + } else { + __pyx_t_10 = __pyx_t_6; + } + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L7:; + __pyx_L5_continue:; + } + } + + /* "saliency_mbd.pyx":105 + * L[x][y] = min(l2,ix) + * + * return True # <<<<<<<<<<<<<< + * + * @cython.boundscheck(False) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "saliency_mbd.pyx":61 + * + * @cython.boundscheck(False) + * cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): # <<<<<<<<<<<<<< + * cdef int n_rows + * cdef int n_cols + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("saliency_mbd.raster_scan_inv", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "saliency_mbd.pyx":108 + * + * @cython.boundscheck(False) + * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters): # <<<<<<<<<<<<<< + * + * L = np.copy(img) + */ + +static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __pyx_v_num_iters) { + PyObject *__pyx_v_L = NULL; + PyObject *__pyx_v_U = NULL; + PyObject *__pyx_v_D = NULL; + int __pyx_v_x; + __Pyx_LocalBuf_ND __pyx_pybuffernd_img; + __Pyx_Buffer __pyx_pybuffer_img; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("mbd", 0); + __pyx_pybuffer_img.pybuffer.buf = NULL; + __pyx_pybuffer_img.refcount = 0; + __pyx_pybuffernd_img.data = NULL; + __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 108, __pyx_L1_error) + } + __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1]; + + /* "saliency_mbd.pyx":110 + * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters): + * + * L = np.copy(img) # <<<<<<<<<<<<<< + * U = np.copy(img) + * D = np.full_like(img, 10000000) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_img)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_L = __pyx_t_1; + __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":111 + * + * L = np.copy(img) + * U = np.copy(img) # <<<<<<<<<<<<<< + * D = np.full_like(img, 10000000) + * D[0,:] = 0 + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_img)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_U = __pyx_t_1; + __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":112 + * L = np.copy(img) + * U = np.copy(img) + * D = np.full_like(img, 10000000) # <<<<<<<<<<<<<< + * D[0,:] = 0 + * D[-1,:] = 0 + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_full_like); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_img), __pyx_int_10000000}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_img), __pyx_int_10000000}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_img)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_img)); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, ((PyObject *)__pyx_v_img)); + __Pyx_INCREF(__pyx_int_10000000); + __Pyx_GIVEREF(__pyx_int_10000000); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_int_10000000); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_D = __pyx_t_1; + __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":113 + * U = np.copy(img) + * D = np.full_like(img, 10000000) + * D[0,:] = 0 # <<<<<<<<<<<<<< + * D[-1,:] = 0 + * D[:,0] = 0 + */ + if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__2, __pyx_int_0) < 0)) __PYX_ERR(0, 113, __pyx_L1_error) + + /* "saliency_mbd.pyx":114 + * D = np.full_like(img, 10000000) + * D[0,:] = 0 + * D[-1,:] = 0 # <<<<<<<<<<<<<< + * D[:,0] = 0 + * D[:,-1] = 0 + */ + if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__3, __pyx_int_0) < 0)) __PYX_ERR(0, 114, __pyx_L1_error) + + /* "saliency_mbd.pyx":115 + * D[0,:] = 0 + * D[-1,:] = 0 + * D[:,0] = 0 # <<<<<<<<<<<<<< + * D[:,-1] = 0 + * + */ + if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__4, __pyx_int_0) < 0)) __PYX_ERR(0, 115, __pyx_L1_error) + + /* "saliency_mbd.pyx":116 + * D[-1,:] = 0 + * D[:,0] = 0 + * D[:,-1] = 0 # <<<<<<<<<<<<<< + * + * cdef int x + */ + if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__5, __pyx_int_0) < 0)) __PYX_ERR(0, 116, __pyx_L1_error) + + /* "saliency_mbd.pyx":119 + * + * cdef int x + * for x in range(0,num_iters): # <<<<<<<<<<<<<< + * if x%2 == 1: + * raster_scan(img,L,U,D) + */ + __pyx_t_4 = __pyx_v_num_iters; + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_x = __pyx_t_7; + + /* "saliency_mbd.pyx":120 + * cdef int x + * for x in range(0,num_iters): + * if x%2 == 1: # <<<<<<<<<<<<<< + * raster_scan(img,L,U,D) + * else: + */ + __pyx_t_8 = ((__Pyx_mod_long(__pyx_v_x, 2) == 1) != 0); + if (__pyx_t_8) { + + /* "saliency_mbd.pyx":121 + * for x in range(0,num_iters): + * if x%2 == 1: + * raster_scan(img,L,U,D) # <<<<<<<<<<<<<< + * else: + * raster_scan_inv(img,L,U,D) + */ + if (!(likely(((__pyx_v_L) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_L, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error) + if (!(likely(((__pyx_v_U) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_U, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error) + if (!(likely(((__pyx_v_D) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_D, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error) + __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":120 + * cdef int x + * for x in range(0,num_iters): + * if x%2 == 1: # <<<<<<<<<<<<<< + * raster_scan(img,L,U,D) + * else: + */ + goto __pyx_L5; + } + + /* "saliency_mbd.pyx":123 + * raster_scan(img,L,U,D) + * else: + * raster_scan_inv(img,L,U,D) # <<<<<<<<<<<<<< + * + * return D + */ + /*else*/ { + if (!(likely(((__pyx_v_L) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_L, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error) + if (!(likely(((__pyx_v_U) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_U, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error) + if (!(likely(((__pyx_v_D) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_D, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error) + __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan_inv(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L5:; + } + + /* "saliency_mbd.pyx":125 + * raster_scan_inv(img,L,U,D) + * + * return D # <<<<<<<<<<<<<< + * + * def f(x): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_D); + __pyx_r = __pyx_v_D; + goto __pyx_L0; + + /* "saliency_mbd.pyx":108 + * + * @cython.boundscheck(False) + * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters): # <<<<<<<<<<<<<< + * + * L = np.copy(img) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("saliency_mbd.mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF(__pyx_v_L); + __Pyx_XDECREF(__pyx_v_U); + __Pyx_XDECREF(__pyx_v_D); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "saliency_mbd.pyx":127 + * return D + * + * def f(x): # <<<<<<<<<<<<<< + * b = 10.0 + * return 1.0 / (1.0 + exp(-b*(x - 0.5))) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_12saliency_mbd_1f(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static PyMethodDef __pyx_mdef_12saliency_mbd_1f = {"f", (PyCFunction)__pyx_pw_12saliency_mbd_1f, METH_O, 0}; +static PyObject *__pyx_pw_12saliency_mbd_1f(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("f (wrapper)", 0); + __pyx_r = __pyx_pf_12saliency_mbd_f(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + double __pyx_v_b; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + double __pyx_t_4; + double __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("f", 0); + + /* "saliency_mbd.pyx":128 + * + * def f(x): + * b = 10.0 # <<<<<<<<<<<<<< + * return 1.0 / (1.0 + exp(-b*(x - 0.5))) + * + */ + __pyx_v_b = 10.0; + + /* "saliency_mbd.pyx":129 + * def f(x): + * b = 10.0 + * return 1.0 / (1.0 + exp(-b*(x - 0.5))) # <<<<<<<<<<<<<< + * + * @cython.boundscheck(False) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble((-__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyFloat_SubtractObjC(__pyx_v_x, __pyx_float_0_5, 0.5, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (1.0 + exp(__pyx_t_4)); + if (unlikely(__pyx_t_5 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 129, __pyx_L1_error) + } + __pyx_t_3 = PyFloat_FromDouble((1.0 / __pyx_t_5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "saliency_mbd.pyx":127 + * return D + * + * def f(x): # <<<<<<<<<<<<<< + * b = 10.0 + * return 1.0 / (1.0 + exp(-b*(x - 0.5))) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("saliency_mbd.f", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "saliency_mbd.pyx":132 + * + * @cython.boundscheck(False) + * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< + * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + * img_mean = np.mean(img,axis=(2)) + */ + +static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_img, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd *__pyx_optional_args) { + PyObject *__pyx_v_img_mean = NULL; + PyObject *__pyx_v_sal = NULL; + int __pyx_v_n_rows; + int __pyx_v_n_cols; + CYTHON_UNUSED int __pyx_v_n_channels; + double __pyx_v_img_size; + PyObject *__pyx_v_border_thickness = NULL; + PyArrayObject *__pyx_v_img_lab = 0; + PyObject *__pyx_v_px_left = NULL; + PyObject *__pyx_v_px_right = NULL; + PyObject *__pyx_v_px_top = NULL; + PyObject *__pyx_v_px_bottom = NULL; + PyObject *__pyx_v_px_mean_left = NULL; + PyObject *__pyx_v_px_mean_right = NULL; + PyObject *__pyx_v_px_mean_top = NULL; + PyObject *__pyx_v_px_mean_bottom = NULL; + PyObject *__pyx_v_cov_left = NULL; + PyObject *__pyx_v_cov_right = NULL; + PyObject *__pyx_v_cov_top = NULL; + PyObject *__pyx_v_cov_bottom = NULL; + PyObject *__pyx_v_u_left = NULL; + PyObject *__pyx_v_u_right = NULL; + PyObject *__pyx_v_u_top = NULL; + PyObject *__pyx_v_u_bottom = NULL; + PyObject *__pyx_v_u_final = NULL; + PyObject *__pyx_v_img_lab_unrolled = NULL; + PyObject *__pyx_v_px_mean_left_2 = NULL; + PyObject *__pyx_v_px_mean_right_2 = NULL; + PyObject *__pyx_v_px_mean_top_2 = NULL; + PyObject *__pyx_v_px_mean_bottom_2 = NULL; + PyObject *__pyx_v_max_u_left = NULL; + PyObject *__pyx_v_max_u_right = NULL; + PyObject *__pyx_v_max_u_top = NULL; + PyObject *__pyx_v_max_u_bottom = NULL; + PyObject *__pyx_v_u_max = NULL; + PyObject *__pyx_v_u_max_final = NULL; + PyObject *__pyx_v_sal_max = NULL; + PyObject *__pyx_v_s = NULL; + double __pyx_v_alpha; + CYTHON_UNUSED double __pyx_v_delta; + PyObject *__pyx_v_xv = NULL; + PyObject *__pyx_v_yv = NULL; + PyObject *__pyx_v_w = NULL; + PyObject *__pyx_v_h = NULL; + double __pyx_v_w2; + double __pyx_v_h2; + PyObject *__pyx_v_C = NULL; + PyObject *__pyx_v_fv = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + double __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_saliency_mbd", 0); + if (__pyx_optional_args) { + } + + /* "saliency_mbd.pyx":134 + * cpdef get_saliency_mbd(np.ndarray img,method='b'): + * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + * img_mean = np.mean(img,axis=(2)) # <<<<<<<<<<<<<< + * sal = mbd(img_mean,2) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_img)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_img)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_img)); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_int_2) < 0) __PYX_ERR(0, 134, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_img_mean = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":135 + * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + * img_mean = np.mean(img,axis=(2)) + * sal = mbd(img_mean,2) # <<<<<<<<<<<<<< + * + * cdef int n_rows = img.shape[0] + */ + if (!(likely(((__pyx_v_img_mean) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_img_mean, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 135, __pyx_L1_error) + __pyx_t_4 = __pyx_f_12saliency_mbd_mbd(((PyArrayObject *)__pyx_v_img_mean), 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_sal = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":137 + * sal = mbd(img_mean,2) + * + * cdef int n_rows = img.shape[0] # <<<<<<<<<<<<<< + * cdef int n_cols = img.shape[1] + * cdef int n_channels = img.shape[2] + */ + __pyx_v_n_rows = (__pyx_v_img->dimensions[0]); + + /* "saliency_mbd.pyx":138 + * + * cdef int n_rows = img.shape[0] + * cdef int n_cols = img.shape[1] # <<<<<<<<<<<<<< + * cdef int n_channels = img.shape[2] + * cdef double img_size = sqrt(n_rows * n_cols) + */ + __pyx_v_n_cols = (__pyx_v_img->dimensions[1]); + + /* "saliency_mbd.pyx":139 + * cdef int n_rows = img.shape[0] + * cdef int n_cols = img.shape[1] + * cdef int n_channels = img.shape[2] # <<<<<<<<<<<<<< + * cdef double img_size = sqrt(n_rows * n_cols) + * border_thickness = int(floor(0.1 * img_size)) + */ + __pyx_v_n_channels = (__pyx_v_img->dimensions[2]); + + /* "saliency_mbd.pyx":140 + * cdef int n_cols = img.shape[1] + * cdef int n_channels = img.shape[2] + * cdef double img_size = sqrt(n_rows * n_cols) # <<<<<<<<<<<<<< + * border_thickness = int(floor(0.1 * img_size)) + * + */ + __pyx_v_img_size = sqrt((__pyx_v_n_rows * __pyx_v_n_cols)); + + /* "saliency_mbd.pyx":141 + * cdef int n_channels = img.shape[2] + * cdef double img_size = sqrt(n_rows * n_cols) + * border_thickness = int(floor(0.1 * img_size)) # <<<<<<<<<<<<<< + * + * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) + */ + __pyx_t_4 = __Pyx_PyInt_FromDouble(floor((0.1 * __pyx_v_img_size))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_border_thickness = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":143 + * border_thickness = int(floor(0.1 * img_size)) + * + * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) # <<<<<<<<<<<<<< + * + * px_left = img_lab[0:border_thickness,:,:] + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_skimage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_color); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_rgb2lab); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_img)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 143, __pyx_L1_error) + __pyx_v_img_lab = ((PyArrayObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":145 + * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) + * + * px_left = img_lab[0:border_thickness,:,:] # <<<<<<<<<<<<<< + * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] + * + */ + __pyx_t_4 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_slice_); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_px_left = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":146 + * + * px_left = img_lab[0:border_thickness,:,:] + * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] # <<<<<<<<<<<<<< + * + * px_top = img_lab[:,0:border_thickness,:] + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_v_border_thickness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PySlice_New(__pyx_t_4, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_slice_); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_px_right = __pyx_t_3; + __pyx_t_3 = 0; + + /* "saliency_mbd.pyx":148 + * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] + * + * px_top = img_lab[:,0:border_thickness,:] # <<<<<<<<<<<<<< + * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] + * + */ + __pyx_t_3 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_slice_); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_px_top = __pyx_t_3; + __pyx_t_3 = 0; + + /* "saliency_mbd.pyx":149 + * + * px_top = img_lab[:,0:border_thickness,:] + * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] # <<<<<<<<<<<<<< + * + * px_mean_left = np.mean(px_left,axis=(0,1)) + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_v_border_thickness); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PySlice_New(__pyx_t_3, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_slice_); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_px_bottom = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":151 + * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] + * + * px_mean_left = np.mean(px_left,axis=(0,1)) # <<<<<<<<<<<<<< + * px_mean_right = np.mean(px_right,axis=(0,1)) + * px_mean_top = np.mean(px_top,axis=(0,1)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_px_left); + __Pyx_GIVEREF(__pyx_v_px_left); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_px_left); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 151, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_px_mean_left = __pyx_t_2; + __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":152 + * + * px_mean_left = np.mean(px_left,axis=(0,1)) + * px_mean_right = np.mean(px_right,axis=(0,1)) # <<<<<<<<<<<<<< + * px_mean_top = np.mean(px_top,axis=(0,1)) + * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_px_right); + __Pyx_GIVEREF(__pyx_v_px_right); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_px_right); + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 152, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_px_mean_right = __pyx_t_3; + __pyx_t_3 = 0; + + /* "saliency_mbd.pyx":153 + * px_mean_left = np.mean(px_left,axis=(0,1)) + * px_mean_right = np.mean(px_right,axis=(0,1)) + * px_mean_top = np.mean(px_top,axis=(0,1)) # <<<<<<<<<<<<<< + * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_px_top); + __Pyx_GIVEREF(__pyx_v_px_top); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_px_top); + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 153, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_px_mean_top = __pyx_t_1; + __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":154 + * px_mean_right = np.mean(px_right,axis=(0,1)) + * px_mean_top = np.mean(px_top,axis=(0,1)) + * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_px_bottom); + __Pyx_GIVEREF(__pyx_v_px_bottom); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_px_bottom); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_px_mean_bottom = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":157 + * + * + * px_left = px_left.reshape((n_cols*border_thickness,3)) # <<<<<<<<<<<<<< + * px_right = px_right.reshape((n_cols*border_thickness,3)) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_px_left, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":158 + * + * px_left = px_left.reshape((n_cols*border_thickness,3)) + * px_right = px_right.reshape((n_cols*border_thickness,3)) # <<<<<<<<<<<<<< + * + * px_top = px_top.reshape((n_rows*border_thickness,3)) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_px_right, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":160 + * px_right = px_right.reshape((n_cols*border_thickness,3)) + * + * px_top = px_top.reshape((n_rows*border_thickness,3)) # <<<<<<<<<<<<<< + * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_px_top, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":161 + * + * px_top = px_top.reshape((n_rows*border_thickness,3)) + * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) # <<<<<<<<<<<<<< + * + * cov_left = np.cov(px_left.T) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_px_bottom, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":163 + * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) + * + * cov_left = np.cov(px_left.T) # <<<<<<<<<<<<<< + * cov_right = np.cov(px_right.T) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_cov_left = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":164 + * + * cov_left = np.cov(px_left.T) + * cov_right = np.cov(px_right.T) # <<<<<<<<<<<<<< + * + * cov_top = np.cov(px_top.T) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cov_right = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":166 + * cov_right = np.cov(px_right.T) + * + * cov_top = np.cov(px_top.T) # <<<<<<<<<<<<<< + * cov_bottom = np.cov(px_bottom.T) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_cov_top = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":167 + * + * cov_top = np.cov(px_top.T) + * cov_bottom = np.cov(px_bottom.T) # <<<<<<<<<<<<<< + * + * cov_left = np.linalg.inv(cov_left) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cov_bottom = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":169 + * cov_bottom = np.cov(px_bottom.T) + * + * cov_left = np.linalg.inv(cov_left) # <<<<<<<<<<<<<< + * cov_right = np.linalg.inv(cov_right) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_left) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_left); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_cov_left, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":170 + * + * cov_left = np.linalg.inv(cov_left) + * cov_right = np.linalg.inv(cov_right) # <<<<<<<<<<<<<< + * + * cov_top = np.linalg.inv(cov_top) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_right) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_right); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_cov_right, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":172 + * cov_right = np.linalg.inv(cov_right) + * + * cov_top = np.linalg.inv(cov_top) # <<<<<<<<<<<<<< + * cov_bottom = np.linalg.inv(cov_bottom) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_top) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_top); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_cov_top, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":173 + * + * cov_top = np.linalg.inv(cov_top) + * cov_bottom = np.linalg.inv(cov_bottom) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_bottom); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_cov_bottom, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":176 + * + * + * u_left = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * u_right = np.zeros(sal.shape) + * u_top = np.zeros(sal.shape) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_u_left = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":177 + * + * u_left = np.zeros(sal.shape) + * u_right = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * u_top = np.zeros(sal.shape) + * u_bottom = np.zeros(sal.shape) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_u_right = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":178 + * u_left = np.zeros(sal.shape) + * u_right = np.zeros(sal.shape) + * u_top = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * u_bottom = np.zeros(sal.shape) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_u_top = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":179 + * u_right = np.zeros(sal.shape) + * u_top = np.zeros(sal.shape) + * u_bottom = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * + * u_final = np.zeros(sal.shape) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_u_bottom = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":181 + * u_bottom = np.zeros(sal.shape) + * + * u_final = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_u_final = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":182 + * + * u_final = np.zeros(sal.shape) + * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) # <<<<<<<<<<<<<< + * + * px_mean_left_2 = np.zeros((1,3)) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_img_lab), __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(((__pyx_v_img_lab->dimensions[0]) * (__pyx_v_img_lab->dimensions[1]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_t_3); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_int_3); + __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_img_lab_unrolled = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":184 + * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) + * + * px_mean_left_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_left_2[0,:] = px_mean_left + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_tuple__7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_px_mean_left_2 = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":185 + * + * px_mean_left_2 = np.zeros((1,3)) + * px_mean_left_2[0,:] = px_mean_left # <<<<<<<<<<<<<< + * + * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) + */ + if (unlikely(PyObject_SetItem(__pyx_v_px_mean_left_2, __pyx_tuple__2, __pyx_v_px_mean_left) < 0)) __PYX_ERR(0, 185, __pyx_L1_error) + + /* "saliency_mbd.pyx":187 + * px_mean_left_2[0,:] = px_mean_left + * + * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) # <<<<<<<<<<<<<< + * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_scipy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_spatial); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_distance); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_cdist); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_img_lab_unrolled); + __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_img_lab_unrolled); + __Pyx_INCREF(__pyx_v_px_mean_left_2); + __Pyx_GIVEREF(__pyx_v_px_mean_left_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_px_mean_left_2); + __Pyx_INCREF(__pyx_n_s_mahalanobis); + __Pyx_GIVEREF(__pyx_n_s_mahalanobis); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_n_s_mahalanobis); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_left) < 0) __PYX_ERR(0, 187, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3); + __pyx_t_3 = 0; + + /* "saliency_mbd.pyx":188 + * + * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) + * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< + * + * px_mean_right_2 = np.zeros((1,3)) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_5); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3); + __pyx_t_3 = 0; + + /* "saliency_mbd.pyx":190 + * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) + * + * px_mean_right_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_right_2[0,:] = px_mean_right + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_tuple__7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_px_mean_right_2 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "saliency_mbd.pyx":191 + * + * px_mean_right_2 = np.zeros((1,3)) + * px_mean_right_2[0,:] = px_mean_right # <<<<<<<<<<<<<< + * + * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) + */ + if (unlikely(PyObject_SetItem(__pyx_v_px_mean_right_2, __pyx_tuple__2, __pyx_v_px_mean_right) < 0)) __PYX_ERR(0, 191, __pyx_L1_error) + + /* "saliency_mbd.pyx":193 + * px_mean_right_2[0,:] = px_mean_right + * + * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) # <<<<<<<<<<<<<< + * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_scipy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_spatial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_distance); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cdist); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_img_lab_unrolled); + __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_img_lab_unrolled); + __Pyx_INCREF(__pyx_v_px_mean_right_2); + __Pyx_GIVEREF(__pyx_v_px_mean_right_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_px_mean_right_2); + __Pyx_INCREF(__pyx_n_s_mahalanobis); + __Pyx_GIVEREF(__pyx_n_s_mahalanobis); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_n_s_mahalanobis); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_right) < 0) __PYX_ERR(0, 193, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5); + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":194 + * + * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) + * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< + * + * px_mean_top_2 = np.zeros((1,3)) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __pyx_t_3 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5); + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":196 + * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) + * + * px_mean_top_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_top_2[0,:] = px_mean_top + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_tuple__7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_px_mean_top_2 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":197 + * + * px_mean_top_2 = np.zeros((1,3)) + * px_mean_top_2[0,:] = px_mean_top # <<<<<<<<<<<<<< + * + * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) + */ + if (unlikely(PyObject_SetItem(__pyx_v_px_mean_top_2, __pyx_tuple__2, __pyx_v_px_mean_top) < 0)) __PYX_ERR(0, 197, __pyx_L1_error) + + /* "saliency_mbd.pyx":199 + * px_mean_top_2[0,:] = px_mean_top + * + * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) # <<<<<<<<<<<<<< + * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_scipy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_spatial); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_distance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_cdist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_img_lab_unrolled); + __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_img_lab_unrolled); + __Pyx_INCREF(__pyx_v_px_mean_top_2); + __Pyx_GIVEREF(__pyx_v_px_mean_top_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_px_mean_top_2); + __Pyx_INCREF(__pyx_n_s_mahalanobis); + __Pyx_GIVEREF(__pyx_n_s_mahalanobis); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_n_s_mahalanobis); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_top) < 0) __PYX_ERR(0, 199, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2); + __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":200 + * + * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) + * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< + * + * px_mean_bottom_2 = np.zeros((1,3)) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); + __pyx_t_5 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2); + __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":202 + * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) + * + * px_mean_bottom_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_bottom_2[0,:] = px_mean_bottom + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_tuple__7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_px_mean_bottom_2 = __pyx_t_2; + __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":203 + * + * px_mean_bottom_2 = np.zeros((1,3)) + * px_mean_bottom_2[0,:] = px_mean_bottom # <<<<<<<<<<<<<< + * + * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) + */ + if (unlikely(PyObject_SetItem(__pyx_v_px_mean_bottom_2, __pyx_tuple__2, __pyx_v_px_mean_bottom) < 0)) __PYX_ERR(0, 203, __pyx_L1_error) + + /* "saliency_mbd.pyx":205 + * px_mean_bottom_2[0,:] = px_mean_bottom + * + * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) # <<<<<<<<<<<<<< + * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_scipy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_spatial); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_distance); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_cdist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_img_lab_unrolled); + __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_img_lab_unrolled); + __Pyx_INCREF(__pyx_v_px_mean_bottom_2); + __Pyx_GIVEREF(__pyx_v_px_mean_bottom_2); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_px_mean_bottom_2); + __Pyx_INCREF(__pyx_n_s_mahalanobis); + __Pyx_GIVEREF(__pyx_n_s_mahalanobis); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_mahalanobis); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_bottom) < 0) __PYX_ERR(0, 205, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":206 + * + * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) + * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< + * + * max_u_left = np.max(u_left) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":208 + * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) + * + * max_u_left = np.max(u_left) # <<<<<<<<<<<<<< + * max_u_right = np.max(u_right) + * max_u_top = np.max(u_top) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_left) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_left); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_max_u_left = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":209 + * + * max_u_left = np.max(u_left) + * max_u_right = np.max(u_right) # <<<<<<<<<<<<<< + * max_u_top = np.max(u_top) + * max_u_bottom = np.max(u_bottom) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_right) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_right); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_max_u_right = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":210 + * max_u_left = np.max(u_left) + * max_u_right = np.max(u_right) + * max_u_top = np.max(u_top) # <<<<<<<<<<<<<< + * max_u_bottom = np.max(u_bottom) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_top) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_top); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_max_u_top = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":211 + * max_u_right = np.max(u_right) + * max_u_top = np.max(u_top) + * max_u_bottom = np.max(u_bottom) # <<<<<<<<<<<<<< + * + * u_left = u_left / max_u_left + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_bottom); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_max_u_bottom = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":213 + * max_u_bottom = np.max(u_bottom) + * + * u_left = u_left / max_u_left # <<<<<<<<<<<<<< + * u_right = u_right / max_u_right + * u_top = u_top / max_u_top + */ + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_left, __pyx_v_max_u_left); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":214 + * + * u_left = u_left / max_u_left + * u_right = u_right / max_u_right # <<<<<<<<<<<<<< + * u_top = u_top / max_u_top + * u_bottom = u_bottom / max_u_bottom + */ + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_right, __pyx_v_max_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":215 + * u_left = u_left / max_u_left + * u_right = u_right / max_u_right + * u_top = u_top / max_u_top # <<<<<<<<<<<<<< + * u_bottom = u_bottom / max_u_bottom + * + */ + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_top, __pyx_v_max_u_top); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":216 + * u_right = u_right / max_u_right + * u_top = u_top / max_u_top + * u_bottom = u_bottom / max_u_bottom # <<<<<<<<<<<<<< + * + * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) + */ + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_bottom, __pyx_v_max_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":218 + * u_bottom = u_bottom / max_u_bottom + * + * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) # <<<<<<<<<<<<<< + * + * u_final = (u_left + u_right + u_top + u_bottom) - u_max + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_maximum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_maximum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_maximum); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_u_left); + __Pyx_GIVEREF(__pyx_v_u_left); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_v_u_left); + __Pyx_INCREF(__pyx_v_u_right); + __Pyx_GIVEREF(__pyx_v_u_right); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_right); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_t_3); + __Pyx_INCREF(__pyx_v_u_top); + __Pyx_GIVEREF(__pyx_v_u_top); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_top); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_t_1); + __Pyx_INCREF(__pyx_v_u_bottom); + __Pyx_GIVEREF(__pyx_v_u_bottom); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_bottom); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_u_max = __pyx_t_4; + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":220 + * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) + * + * u_final = (u_left + u_right + u_top + u_bottom) - u_max # <<<<<<<<<<<<<< + * + * u_max_final = np.max(u_final) + */ + __pyx_t_4 = PyNumber_Add(__pyx_v_u_left, __pyx_v_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_v_u_top); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_v_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_v_u_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_u_final, __pyx_t_5); + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":222 + * u_final = (u_left + u_right + u_top + u_bottom) - u_max + * + * u_max_final = np.max(u_final) # <<<<<<<<<<<<<< + * sal_max = np.max(sal) + * sal = sal / sal_max + u_final / u_max_final + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_u_final) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_u_final); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_u_max_final = __pyx_t_5; + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":223 + * + * u_max_final = np.max(u_final) + * sal_max = np.max(sal) # <<<<<<<<<<<<<< + * sal = sal / sal_max + u_final / u_max_final + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_sal_max = __pyx_t_5; + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":224 + * u_max_final = np.max(u_final) + * sal_max = np.max(sal) + * sal = sal / sal_max + u_final / u_max_final # <<<<<<<<<<<<<< + * + * #postprocessing + */ + __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_v_sal_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_final, __pyx_v_u_max_final); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_9); + __pyx_t_9 = 0; + + /* "saliency_mbd.pyx":229 + * + * # apply centredness map + * sal = sal / np.max(sal) # <<<<<<<<<<<<<< + * + * s = np.mean(sal) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_9 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_5); + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":231 + * sal = sal / np.max(sal) + * + * s = np.mean(sal) # <<<<<<<<<<<<<< + * cdef double alpha = 50.0 + * cdef double delta = alpha * sqrt(s) + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_s = __pyx_t_5; + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":232 + * + * s = np.mean(sal) + * cdef double alpha = 50.0 # <<<<<<<<<<<<<< + * cdef double delta = alpha * sqrt(s) + * + */ + __pyx_v_alpha = 50.0; + + /* "saliency_mbd.pyx":233 + * s = np.mean(sal) + * cdef double alpha = 50.0 + * cdef double delta = alpha * sqrt(s) # <<<<<<<<<<<<<< + * + * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) + */ + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_s); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 233, __pyx_L1_error) + __pyx_v_delta = (__pyx_v_alpha * sqrt(__pyx_t_10)); + + /* "saliency_mbd.pyx":235 + * cdef double delta = alpha * sqrt(s) + * + * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) # <<<<<<<<<<<<<< + * (w,h) = sal.shape + * cdef double w2 = w/2.0 + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_meshgrid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_arange); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_1) { + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); __pyx_t_1 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_6, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_6, __pyx_t_2); + __pyx_t_4 = 0; + __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 235, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_9 = PyList_GET_ITEM(sequence, 0); + __pyx_t_8 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(__pyx_t_8); + #else + __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext; + index = 0; __pyx_t_9 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_9); + index = 1; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 235, __pyx_L1_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 235, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_v_xv = __pyx_t_9; + __pyx_t_9 = 0; + __pyx_v_yv = __pyx_t_8; + __pyx_t_8 = 0; + + /* "saliency_mbd.pyx":236 + * + * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) + * (w,h) = sal.shape # <<<<<<<<<<<<<< + * cdef double w2 = w/2.0 + * cdef double h2 = h/2.0 + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 236, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_8 = PyList_GET_ITEM(sequence, 0); + __pyx_t_9 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + #else + __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext; + index = 0; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + index = 1; __pyx_t_9 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_v_w = __pyx_t_8; + __pyx_t_8 = 0; + __pyx_v_h = __pyx_t_9; + __pyx_t_9 = 0; + + /* "saliency_mbd.pyx":237 + * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) + * (w,h) = sal.shape + * cdef double w2 = w/2.0 # <<<<<<<<<<<<<< + * cdef double h2 = h/2.0 + * + */ + __pyx_t_5 = __Pyx_PyFloat_DivideObjC(__pyx_v_w, __pyx_float_2_0, 2.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_w2 = __pyx_t_10; + + /* "saliency_mbd.pyx":238 + * (w,h) = sal.shape + * cdef double w2 = w/2.0 + * cdef double h2 = h/2.0 # <<<<<<<<<<<<<< + * + * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) + */ + __pyx_t_5 = __Pyx_PyFloat_DivideObjC(__pyx_v_h, __pyx_float_2_0, 2.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_h2 = __pyx_t_10; + + /* "saliency_mbd.pyx":240 + * cdef double h2 = h/2.0 + * + * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) # <<<<<<<<<<<<<< + * + * sal = sal * C + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyNumber_Subtract(__pyx_v_xv, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_t_1); + __Pyx_INCREF(__pyx_int_2); + __Pyx_GIVEREF(__pyx_int_2); + PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_int_2); + __pyx_t_1 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Subtract(__pyx_v_yv, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_2); + __Pyx_INCREF(__pyx_int_2); + __Pyx_GIVEREF(__pyx_int_2); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2); + __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_1, __pyx_int_2}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_1, __pyx_int_2}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_1); + __Pyx_INCREF(__pyx_int_2); + __Pyx_GIVEREF(__pyx_int_2); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2); + __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_int_2}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_int_2}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_t_7); + __Pyx_INCREF(__pyx_int_2); + __Pyx_GIVEREF(__pyx_int_2); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_int_2); + __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyFloat_FromDouble(sqrt(__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_SubtractCObj(__pyx_int_1, __pyx_t_4, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_C = __pyx_t_1; + __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":242 + * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) + * + * sal = sal * C # <<<<<<<<<<<<<< + * + * fv = np.vectorize(f) + */ + __pyx_t_1 = PyNumber_Multiply(__pyx_v_sal, __pyx_v_C); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_1); + __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":244 + * sal = sal * C + * + * fv = np.vectorize(f) # <<<<<<<<<<<<<< + * + * sal = sal / np.max(sal) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_vectorize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_8, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_fv = __pyx_t_1; + __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":246 + * fv = np.vectorize(f) + * + * sal = sal / np.max(sal) # <<<<<<<<<<<<<< + * + * sal = fv(sal) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":248 + * sal = sal / np.max(sal) + * + * sal = fv(sal) # <<<<<<<<<<<<<< + * + * return sal* 255.0 + */ + __Pyx_INCREF(__pyx_v_fv); + __pyx_t_1 = __pyx_v_fv; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4); + __pyx_t_4 = 0; + + /* "saliency_mbd.pyx":250 + * sal = fv(sal) + * + * return sal* 255.0 # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "saliency_mbd.pyx":132 + * + * @cython.boundscheck(False) + * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< + * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + * img_mean = np.mean(img,axis=(2)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_img_mean); + __Pyx_XDECREF(__pyx_v_sal); + __Pyx_XDECREF(__pyx_v_border_thickness); + __Pyx_XDECREF((PyObject *)__pyx_v_img_lab); + __Pyx_XDECREF(__pyx_v_px_left); + __Pyx_XDECREF(__pyx_v_px_right); + __Pyx_XDECREF(__pyx_v_px_top); + __Pyx_XDECREF(__pyx_v_px_bottom); + __Pyx_XDECREF(__pyx_v_px_mean_left); + __Pyx_XDECREF(__pyx_v_px_mean_right); + __Pyx_XDECREF(__pyx_v_px_mean_top); + __Pyx_XDECREF(__pyx_v_px_mean_bottom); + __Pyx_XDECREF(__pyx_v_cov_left); + __Pyx_XDECREF(__pyx_v_cov_right); + __Pyx_XDECREF(__pyx_v_cov_top); + __Pyx_XDECREF(__pyx_v_cov_bottom); + __Pyx_XDECREF(__pyx_v_u_left); + __Pyx_XDECREF(__pyx_v_u_right); + __Pyx_XDECREF(__pyx_v_u_top); + __Pyx_XDECREF(__pyx_v_u_bottom); + __Pyx_XDECREF(__pyx_v_u_final); + __Pyx_XDECREF(__pyx_v_img_lab_unrolled); + __Pyx_XDECREF(__pyx_v_px_mean_left_2); + __Pyx_XDECREF(__pyx_v_px_mean_right_2); + __Pyx_XDECREF(__pyx_v_px_mean_top_2); + __Pyx_XDECREF(__pyx_v_px_mean_bottom_2); + __Pyx_XDECREF(__pyx_v_max_u_left); + __Pyx_XDECREF(__pyx_v_max_u_right); + __Pyx_XDECREF(__pyx_v_max_u_top); + __Pyx_XDECREF(__pyx_v_max_u_bottom); + __Pyx_XDECREF(__pyx_v_u_max); + __Pyx_XDECREF(__pyx_v_u_max_final); + __Pyx_XDECREF(__pyx_v_sal_max); + __Pyx_XDECREF(__pyx_v_s); + __Pyx_XDECREF(__pyx_v_xv); + __Pyx_XDECREF(__pyx_v_yv); + __Pyx_XDECREF(__pyx_v_w); + __Pyx_XDECREF(__pyx_v_h); + __Pyx_XDECREF(__pyx_v_C); + __Pyx_XDECREF(__pyx_v_fv); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_img = 0; + PyObject *__pyx_v_method = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_saliency_mbd (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_img,&__pyx_n_s_method,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)__pyx_n_s_b); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_img)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 132, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_img = ((PyArrayObject *)values[0]); + __pyx_v_method = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 132, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_r = __pyx_pf_12saliency_mbd_2get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_saliency_mbd", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.method = __pyx_v_method; + __pyx_t_1 = __pyx_f_12saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fulfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyArray_Descr *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * + * cdef int i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * cdef int i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (unlikely(__pyx_t_1)) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 272, __pyx_L1_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L7_bool_binop_done; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L7_bool_binop_done:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (unlikely(__pyx_t_1)) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 276, __pyx_L1_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * # This is allocated as one block, strides first. + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L9; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L9:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = PyArray_DESCR(self) + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_7 = PyArray_DESCR(__pyx_v_self); + __pyx_t_3 = ((PyObject *)__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 + * cdef int offset + * + * info.obj = self # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(descr): + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 + * info.obj = self + * + * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); + if (__pyx_t_1) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 + * + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L15_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; + } + __pyx_L15_next_or:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L14_bool_binop_done:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (unlikely(__pyx_t_1)) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 306, __pyx_L1_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = ((char *)"b"); + break; + case NPY_UBYTE: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + __pyx_v_f = ((char *)"B"); + break; + case NPY_SHORT: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + __pyx_v_f = ((char *)"h"); + break; + case NPY_USHORT: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + __pyx_v_f = ((char *)"H"); + break; + case NPY_INT: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + __pyx_v_f = ((char *)"i"); + break; + case NPY_UINT: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + __pyx_v_f = ((char *)"I"); + break; + case NPY_LONG: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + __pyx_v_f = ((char *)"l"); + break; + case NPY_ULONG: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + __pyx_v_f = ((char *)"L"); + break; + case NPY_LONGLONG: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + __pyx_v_f = ((char *)"q"); + break; + case NPY_ULONGLONG: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + __pyx_v_f = ((char *)"Q"); + break; + case NPY_FLOAT: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + __pyx_v_f = ((char *)"f"); + break; + case NPY_DOUBLE: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + __pyx_v_f = ((char *)"d"); + break; + case NPY_LONGDOUBLE: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + __pyx_v_f = ((char *)"g"); + break; + case NPY_CFLOAT: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + __pyx_v_f = ((char *)"Zf"); + break; + case NPY_CDOUBLE: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + __pyx_v_f = ((char *)"Zd"); + break; + case NPY_CLONGDOUBLE: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + __pyx_v_f = ((char *)"Zg"); + break; + case NPY_OBJECT: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_v_f = ((char *)"O"); + break; + default: + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 325, __pyx_L1_error) + break; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 + * info.obj = self + * + * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 + * return + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 + * info.format = PyObject_Malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_9 = __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_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fulfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * PyObject_Free(info.strides) + */ + PyObject_Free(__pyx_v_info->format); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * PyObject_Free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * PyObject_Free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + PyObject_Free(__pyx_v_info->strides); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * PyObject_Free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 824, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 833, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * return () + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":846 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 850, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 850, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 850, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 851, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 851, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 852, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 852, __pyx_L1_error) + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 852, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 854, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 854, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 854, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (unlikely(__pyx_t_6)) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 855, __pyx_L1_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (unlikely(__pyx_t_6)) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 859, __pyx_L1_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":869 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 869, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 869, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":874 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 877, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (unlikely(__pyx_t_6)) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 879, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 879, __pyx_L1_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":882 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 882, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 882, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(__pyx_t_6)) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":900 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 900, __pyx_L1_error) + } + __pyx_L15:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":905 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 905, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * return () + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * + */ + Py_INCREF(__pyx_v_base); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * _import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + * cdef inline int import_array() except -1: + * try: + * _import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1035, __pyx_L3_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 + * try: + * _import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1036, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 + * _import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1037, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1037, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * _import_array() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1041, __pyx_L3_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1042, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1043, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1043, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1047, __pyx_L3_error) + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1048, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1049, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1049, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {"get_saliency_mbd", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_12saliency_mbd_3get_saliency_mbd, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_saliency_mbd(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_saliency_mbd}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "saliency_mbd", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_T, __pyx_k_T, sizeof(__pyx_k_T), 0, 0, 1, 1}, + {&__pyx_n_s_VI, __pyx_k_VI, sizeof(__pyx_k_VI), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_arange, __pyx_k_arange, sizeof(__pyx_k_arange), 0, 0, 1, 1}, + {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1}, + {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, + {&__pyx_n_s_cdist, __pyx_k_cdist, sizeof(__pyx_k_cdist), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_color, __pyx_k_color, sizeof(__pyx_k_color), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_cov, __pyx_k_cov, sizeof(__pyx_k_cov), 0, 0, 1, 1}, + {&__pyx_n_s_distance, __pyx_k_distance, sizeof(__pyx_k_distance), 0, 0, 1, 1}, + {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1}, + {&__pyx_n_s_full_like, __pyx_k_full_like, sizeof(__pyx_k_full_like), 0, 0, 1, 1}, + {&__pyx_n_s_img, __pyx_k_img, sizeof(__pyx_k_img), 0, 0, 1, 1}, + {&__pyx_n_s_img_as_float, __pyx_k_img_as_float, sizeof(__pyx_k_img_as_float), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_inv, __pyx_k_inv, sizeof(__pyx_k_inv), 0, 0, 1, 1}, + {&__pyx_n_s_linalg, __pyx_k_linalg, sizeof(__pyx_k_linalg), 0, 0, 1, 1}, + {&__pyx_n_s_mahalanobis, __pyx_k_mahalanobis, sizeof(__pyx_k_mahalanobis), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, + {&__pyx_n_s_maximum, __pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 0, 1, 1}, + {&__pyx_n_s_mean, __pyx_k_mean, sizeof(__pyx_k_mean), 0, 0, 1, 1}, + {&__pyx_n_s_meshgrid, __pyx_k_meshgrid, sizeof(__pyx_k_meshgrid), 0, 0, 1, 1}, + {&__pyx_n_s_method, __pyx_k_method, sizeof(__pyx_k_method), 0, 0, 1, 1}, + {&__pyx_n_s_minimize, __pyx_k_minimize, sizeof(__pyx_k_minimize), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, + {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, + {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_reshape, __pyx_k_reshape, sizeof(__pyx_k_reshape), 0, 0, 1, 1}, + {&__pyx_n_s_rgb2lab, __pyx_k_rgb2lab, sizeof(__pyx_k_rgb2lab), 0, 0, 1, 1}, + {&__pyx_n_s_saliency_mbd, __pyx_k_saliency_mbd, sizeof(__pyx_k_saliency_mbd), 0, 0, 1, 1}, + {&__pyx_kp_s_saliency_mbd_pyx, __pyx_k_saliency_mbd_pyx, sizeof(__pyx_k_saliency_mbd_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_scipy, __pyx_k_scipy, sizeof(__pyx_k_scipy), 0, 0, 1, 1}, + {&__pyx_n_s_scipy_optimize, __pyx_k_scipy_optimize, sizeof(__pyx_k_scipy_optimize), 0, 0, 1, 1}, + {&__pyx_n_s_scipy_spatial_distance, __pyx_k_scipy_spatial_distance, sizeof(__pyx_k_scipy_spatial_distance), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_skimage, __pyx_k_skimage, sizeof(__pyx_k_skimage), 0, 0, 1, 1}, + {&__pyx_n_s_skimage_io, __pyx_k_skimage_io, sizeof(__pyx_k_skimage_io), 0, 0, 1, 1}, + {&__pyx_n_s_skimage_util, __pyx_k_skimage_util, sizeof(__pyx_k_skimage_util), 0, 0, 1, 1}, + {&__pyx_n_s_spatial, __pyx_k_spatial, sizeof(__pyx_k_spatial), 0, 0, 1, 1}, + {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1}, + {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_vectorize, __pyx_k_vectorize, sizeof(__pyx_k_vectorize), 0, 0, 1, 1}, + {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 855, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1037, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "saliency_mbd.pyx":113 + * U = np.copy(img) + * D = np.full_like(img, 10000000) + * D[0,:] = 0 # <<<<<<<<<<<<<< + * D[-1,:] = 0 + * D[:,0] = 0 + */ + __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + __pyx_tuple__2 = PyTuple_Pack(2, __pyx_int_0, __pyx_slice_); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "saliency_mbd.pyx":114 + * D = np.full_like(img, 10000000) + * D[0,:] = 0 + * D[-1,:] = 0 # <<<<<<<<<<<<<< + * D[:,0] = 0 + * D[:,-1] = 0 + */ + __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_neg_1, __pyx_slice_); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "saliency_mbd.pyx":115 + * D[0,:] = 0 + * D[-1,:] = 0 + * D[:,0] = 0 # <<<<<<<<<<<<<< + * D[:,-1] = 0 + * + */ + __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "saliency_mbd.pyx":116 + * D[-1,:] = 0 + * D[:,0] = 0 + * D[:,-1] = 0 # <<<<<<<<<<<<<< + * + * cdef int x + */ + __pyx_tuple__5 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "saliency_mbd.pyx":151 + * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] + * + * px_mean_left = np.mean(px_left,axis=(0,1)) # <<<<<<<<<<<<<< + * px_mean_right = np.mean(px_right,axis=(0,1)) + * px_mean_top = np.mean(px_top,axis=(0,1)) + */ + __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "saliency_mbd.pyx":184 + * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) + * + * px_mean_left_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_left_2[0,:] = px_mean_left + * + */ + __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_3); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 879, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 + * _import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 1037, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 1043, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "saliency_mbd.pyx":127 + * return D + * + * def f(x): # <<<<<<<<<<<<<< + * b = 10.0 + * return 1.0 / (1.0 + exp(-b*(x - 0.5))) + */ + __pyx_tuple__15 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_b); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_saliency_mbd_pyx, __pyx_n_s_f, 127, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_float_0_5 = PyFloat_FromDouble(0.5); if (unlikely(!__pyx_float_0_5)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_2_0 = PyFloat_FromDouble(2.0); if (unlikely(!__pyx_float_2_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_255_0 = PyFloat_FromDouble(255.0); if (unlikely(!__pyx_float_255_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_10000000 = PyInt_FromLong(10000000L); if (unlikely(!__pyx_int_10000000)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 917, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initsaliency_mbd(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initsaliency_mbd(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_saliency_mbd(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'saliency_mbd' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("saliency_mbd", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_saliency_mbd) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "saliency_mbd")) { + if (unlikely(PyDict_SetItemString(modules, "saliency_mbd", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "saliency_mbd.pyx":1 + * import sys # <<<<<<<<<<<<<< + * import numpy as np + * cimport numpy as np + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":2 + * import sys + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * import scipy.spatial.distance + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":4 + * import numpy as np + * cimport numpy as np + * import scipy.spatial.distance # <<<<<<<<<<<<<< + * import skimage + * import skimage.io + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_spatial_distance, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_scipy, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":5 + * cimport numpy as np + * import scipy.spatial.distance + * import skimage # <<<<<<<<<<<<<< + * import skimage.io + * from skimage.util import img_as_float + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":6 + * import scipy.spatial.distance + * import skimage + * import skimage.io # <<<<<<<<<<<<<< + * from skimage.util import img_as_float + * from scipy.optimize import minimize + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage_io, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":7 + * import skimage + * import skimage.io + * from skimage.util import img_as_float # <<<<<<<<<<<<<< + * from scipy.optimize import minimize + * cimport cython + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_img_as_float); + __Pyx_GIVEREF(__pyx_n_s_img_as_float); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_img_as_float); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_skimage_util, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_img_as_float, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "saliency_mbd.pyx":8 + * import skimage.io + * from skimage.util import img_as_float + * from scipy.optimize import minimize # <<<<<<<<<<<<<< + * cimport cython + * from libc.math cimport exp, floor, sqrt + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_minimize); + __Pyx_GIVEREF(__pyx_n_s_minimize); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_minimize); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_optimize, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_minimize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_minimize, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":12 + * from libc.math cimport exp, floor, sqrt + * + * np.import_array() # <<<<<<<<<<<<<< + * + * @cython.boundscheck(False) + */ + __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 12, __pyx_L1_error) + + /* "saliency_mbd.pyx":127 + * return D + * + * def f(x): # <<<<<<<<<<<<<< + * b = 10.0 + * return 1.0 / (1.0 + exp(-b*(x - 0.5))) + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12saliency_mbd_1f, NULL, __pyx_n_s_saliency_mbd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_f, __pyx_t_1) < 0) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "saliency_mbd.pyx":1 + * import sys # <<<<<<<<<<<<<< + * import numpy as np + * cimport numpy as np + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init saliency_mbd"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} +static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + buf->buf = NULL; + if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; +} + +/* GetItemInt */ + static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* SetItemInt */ + static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (!j) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); + } + } + return m->sq_ass_item(o, i, v); + } + } +#else +#if CYTHON_COMPILING_IN_PYPY + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) +#else + if (is_list || PySequence_Check(o)) +#endif + { + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* PyDictVersioning */ + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ + #if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCall2Args */ + static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* None */ + static CYTHON_INLINE long __Pyx_mod_long(long a, long b) { + long r = a % b; + r += ((r != 0) & ((r ^ b) < 0)) * b; + return r; +} + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* PyFloatBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { + const double b = floatval; + double a, result; + (void)inplace; + (void)zerodivision_check; + if (likely(PyFloat_CheckExact(op1))) { + a = PyFloat_AS_DOUBLE(op1); + + } else + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + a = (double) PyInt_AS_LONG(op1); + + } else + #endif + if (likely(PyLong_CheckExact(op1))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + switch (size) { + case 0: a = 0.0; break; + case -1: a = -(double) digits[0]; break; + case 1: a = (double) digits[0]; break; + case -2: + case 2: + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) { + a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -2) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + case -3: + case 3: + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) { + a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -3) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + case -4: + case 4: + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) { + a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -4) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + default: + #else + { + #endif + a = PyLong_AsDouble(op1); + if (unlikely(a == -1.0 && PyErr_Occurred())) return NULL; + + } + } else { + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); + } + + PyFPE_START_PROTECT("subtract", return NULL) + result = a - b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); +} +#endif + +/* PyIntFromDouble */ + #if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value) { + if (value >= (double)LONG_MIN && value <= (double)LONG_MAX) { + return PyInt_FromLong((long)value); + } + return PyLong_FromDouble(value); +} +#endif + +/* ObjectGetItem */ + #if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* PyIntBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + } + x = a - b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); +} +#endif + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* PyFloatBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { + const double b = floatval; + double a, result; + (void)inplace; + (void)zerodivision_check; + if (likely(PyFloat_CheckExact(op1))) { + a = PyFloat_AS_DOUBLE(op1); + + } else + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + a = (double) PyInt_AS_LONG(op1); + + } else + #endif + if (likely(PyLong_CheckExact(op1))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + switch (size) { + case 0: a = 0.0; break; + case -1: a = -(double) digits[0]; break; + case 1: a = (double) digits[0]; break; + case -2: + case 2: + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) { + a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -2) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + case -3: + case 3: + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) { + a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -3) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + case -4: + case 4: + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) { + a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -4) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + default: + #else + { + #endif + a = PyLong_AsDouble(op1); + if (unlikely(a == -1.0 && PyErr_Occurred())) return NULL; + + } + } else { + return (inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2)); + } + + PyFPE_START_PROTECT("divide", return NULL) + result = a / b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); +} +#endif + +/* PyIntBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op2))) { + const long a = intval; + long x; + long b = PyInt_AS_LONG(op2); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op2))) { + const long a = intval; + long b, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG lla = intval; + PY_LONG_LONG llb, llx; +#endif + const digit* digits = ((PyLongObject*)op2)->ob_digit; + const Py_ssize_t size = Py_SIZE(op2); + if (likely(__Pyx_sst_abs(size) <= 1)) { + b = likely(size) ? digits[0] : 0; + if (size == -1) b = -b; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + b = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + b = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + b = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + b = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + b = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + b = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + } + x = a - b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op2)) { + const long a = intval; + double b = PyFloat_AS_DOUBLE(op2); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); +} +#endif + +/* RaiseDoubleKeywords */ + static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ + static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* RaiseArgTupleInvalid */ + static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* ArgTypeTest */ + static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* DictGetItem */ + #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* RaiseNoneIterError */ + static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* GetTopmostException */ + #if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* ImportFrom */ + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* CLineInTraceback */ + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + + /* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) { + const Py_intptr_t neg_one = (Py_intptr_t) ((Py_intptr_t) 0 - (Py_intptr_t) 1), const_zero = (Py_intptr_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(Py_intptr_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(Py_intptr_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t), + little, !is_unsigned); + } +} + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; ip) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + 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])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + 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])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/perception/tasks/segmentation/saliency_detection/saliency_mbd.html b/perception/tasks/segmentation/saliency_detection/saliency_mbd.html new file mode 100644 index 0000000..1f32e95 --- /dev/null +++ b/perception/tasks/segmentation/saliency_detection/saliency_mbd.html @@ -0,0 +1,3766 @@ + + + + + + Cython: saliency_mbd.pyx + + + +

Generated by Cython 0.29.21

+

+ Yellow lines hint at Python interaction.
+ Click on a line that starts with a "+" to see the C code that Cython generated for it. +

+

Raw output: saliency_mbd.c

+
+001: import sys
+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+/* … */
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+002: import numpy as np
+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 003: cimport numpy as np
+
+004: import scipy.spatial.distance
+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_spatial_distance, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_scipy, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+005: import skimage
+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+006: import skimage.io
+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage_io, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+007: from skimage.util import img_as_float
+
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_n_s_img_as_float);
+  __Pyx_GIVEREF(__pyx_n_s_img_as_float);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_img_as_float);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_skimage_util, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_img_as_float, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+008: from scipy.optimize import minimize
+
  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_n_s_minimize);
+  __Pyx_GIVEREF(__pyx_n_s_minimize);
+  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_minimize);
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_optimize, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_minimize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_minimize, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 009: cimport cython
+
 010: from libc.math cimport exp, floor, sqrt
+
 011:
+
+012: np.import_array()
+
  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 12, __pyx_L1_error)
+
 013:
+
 014: @cython.boundscheck(False)
+
+015: cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
+
static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) {
+  int __pyx_v_n_rows;
+  int __pyx_v_n_cols;
+  int __pyx_v_x;
+  int __pyx_v_y;
+  double __pyx_v_ix;
+  double __pyx_v_d;
+  double __pyx_v_u1;
+  double __pyx_v_l1;
+  double __pyx_v_u2;
+  double __pyx_v_l2;
+  double __pyx_v_b1;
+  double __pyx_v_b2;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_D;
+  __Pyx_Buffer __pyx_pybuffer_D;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_L;
+  __Pyx_Buffer __pyx_pybuffer_L;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_U;
+  __Pyx_Buffer __pyx_pybuffer_U;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_img;
+  __Pyx_Buffer __pyx_pybuffer_img;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("raster_scan", 0);
+  __pyx_pybuffer_img.pybuffer.buf = NULL;
+  __pyx_pybuffer_img.refcount = 0;
+  __pyx_pybuffernd_img.data = NULL;
+  __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img;
+  __pyx_pybuffer_L.pybuffer.buf = NULL;
+  __pyx_pybuffer_L.refcount = 0;
+  __pyx_pybuffernd_L.data = NULL;
+  __pyx_pybuffernd_L.rcbuffer = &__pyx_pybuffer_L;
+  __pyx_pybuffer_U.pybuffer.buf = NULL;
+  __pyx_pybuffer_U.refcount = 0;
+  __pyx_pybuffernd_U.data = NULL;
+  __pyx_pybuffernd_U.rcbuffer = &__pyx_pybuffer_U;
+  __pyx_pybuffer_D.pybuffer.buf = NULL;
+  __pyx_pybuffer_D.refcount = 0;
+  __pyx_pybuffernd_D.data = NULL;
+  __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1];
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_9);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("saliency_mbd.raster_scan", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
 016: 	cdef int n_rows
+
 017: 	cdef int n_cols
+
 018:
+
+019: 	n_rows = len(img)
+
  __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_img)); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error)
+  __pyx_v_n_rows = __pyx_t_1;
+
+020: 	n_cols = len(img[0])
+
  __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_n_cols = __pyx_t_1;
+
 021:
+
 022: 	cdef int x
+
 023: 	cdef int y
+
 024: 	cdef double ix
+
 025: 	cdef double d
+
 026: 	cdef double u1
+
 027: 	cdef double l1
+
 028: 	cdef double u2
+
 029: 	cdef double l2
+
 030: 	cdef double b1
+
 031: 	cdef double b2
+
 032:
+
+033: 	for x in range(1,n_rows - 1):
+
  __pyx_t_3 = (__pyx_v_n_rows - 1);
+  __pyx_t_4 = __pyx_t_3;
+  for (__pyx_t_5 = 1; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+    __pyx_v_x = __pyx_t_5;
+
+034: 		for y in range(1,n_cols - 1):
+
    __pyx_t_6 = (__pyx_v_n_cols - 1);
+    __pyx_t_7 = __pyx_t_6;
+    for (__pyx_t_8 = 1; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
+      __pyx_v_y = __pyx_t_8;
+
+035: 			ix = img[x][y]
+
      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_v_ix = __pyx_t_10;
+
+036: 			d = D[x][y]
+
      __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 36, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_d = __pyx_t_10;
+
 037:
+
+038: 			u1 = U[x-1][y]
+
      __pyx_t_11 = (__pyx_v_x - 1);
+      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 38, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_v_u1 = __pyx_t_10;
+
+039: 			l1 = L[x-1][y]
+
      __pyx_t_11 = (__pyx_v_x - 1);
+      __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 39, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_l1 = __pyx_t_10;
+
 040:
+
+041: 			u2 = U[x][y-1]
+
      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_11 = (__pyx_v_y - 1);
+      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 41, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_v_u2 = __pyx_t_10;
+
+042: 			l2 = L[x][y-1]
+
      __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 42, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_11 = (__pyx_v_y - 1);
+      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_l2 = __pyx_t_10;
+
 043:
+
+044: 			b1 = max(u1,ix) - min(l1,ix)
+
      __pyx_t_10 = __pyx_v_ix;
+      __pyx_t_12 = __pyx_v_u1;
+      if (((__pyx_t_10 > __pyx_t_12) != 0)) {
+        __pyx_t_13 = __pyx_t_10;
+      } else {
+        __pyx_t_13 = __pyx_t_12;
+      }
+      __pyx_t_10 = __pyx_v_ix;
+      __pyx_t_12 = __pyx_v_l1;
+      if (((__pyx_t_10 < __pyx_t_12) != 0)) {
+        __pyx_t_14 = __pyx_t_10;
+      } else {
+        __pyx_t_14 = __pyx_t_12;
+      }
+      __pyx_v_b1 = (__pyx_t_13 - __pyx_t_14);
+
+045: 			b2 = max(u2,ix) - min(l2,ix)
+
      __pyx_t_14 = __pyx_v_ix;
+      __pyx_t_13 = __pyx_v_u2;
+      if (((__pyx_t_14 > __pyx_t_13) != 0)) {
+        __pyx_t_10 = __pyx_t_14;
+      } else {
+        __pyx_t_10 = __pyx_t_13;
+      }
+      __pyx_t_14 = __pyx_v_ix;
+      __pyx_t_13 = __pyx_v_l2;
+      if (((__pyx_t_14 < __pyx_t_13) != 0)) {
+        __pyx_t_12 = __pyx_t_14;
+      } else {
+        __pyx_t_12 = __pyx_t_13;
+      }
+      __pyx_v_b2 = (__pyx_t_10 - __pyx_t_12);
+
 046:
+
+047: 			if d <= b1 and d <= b2:
+
      __pyx_t_16 = ((__pyx_v_d <= __pyx_v_b1) != 0);
+      if (__pyx_t_16) {
+      } else {
+        __pyx_t_15 = __pyx_t_16;
+        goto __pyx_L8_bool_binop_done;
+      }
+      __pyx_t_16 = ((__pyx_v_d <= __pyx_v_b2) != 0);
+      __pyx_t_15 = __pyx_t_16;
+      __pyx_L8_bool_binop_done:;
+      if (__pyx_t_15) {
+/* … */
+      }
+
+048: 				continue
+
        goto __pyx_L5_continue;
+
+049: 			elif b1 < d and b1 <= b2:
+
      __pyx_t_16 = ((__pyx_v_b1 < __pyx_v_d) != 0);
+      if (__pyx_t_16) {
+      } else {
+        __pyx_t_15 = __pyx_t_16;
+        goto __pyx_L10_bool_binop_done;
+      }
+      __pyx_t_16 = ((__pyx_v_b1 <= __pyx_v_b2) != 0);
+      __pyx_t_15 = __pyx_t_16;
+      __pyx_L10_bool_binop_done:;
+      if (__pyx_t_15) {
+/* … */
+        goto __pyx_L7;
+      }
+
+050: 				D[x][y] = b1
+
        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 50, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 50, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+051: 				U[x][y] = max(u1,ix)
+
        __pyx_t_12 = __pyx_v_ix;
+        __pyx_t_10 = __pyx_v_u1;
+        if (((__pyx_t_12 > __pyx_t_10) != 0)) {
+          __pyx_t_14 = __pyx_t_12;
+        } else {
+          __pyx_t_14 = __pyx_t_10;
+        }
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 51, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 51, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+052: 				L[x][y] = min(l1,ix)
+
        __pyx_t_14 = __pyx_v_ix;
+        __pyx_t_12 = __pyx_v_l1;
+        if (((__pyx_t_14 < __pyx_t_12) != 0)) {
+          __pyx_t_10 = __pyx_t_14;
+        } else {
+          __pyx_t_10 = __pyx_t_12;
+        }
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 52, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 52, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
 053: 			else:
+
+054: 				D[x][y] = b2
+
      /*else*/ {
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 54, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+055: 				U[x][y] = max(u2,ix)
+
        __pyx_t_10 = __pyx_v_ix;
+        __pyx_t_14 = __pyx_v_u2;
+        if (((__pyx_t_10 > __pyx_t_14) != 0)) {
+          __pyx_t_12 = __pyx_t_10;
+        } else {
+          __pyx_t_12 = __pyx_t_14;
+        }
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 55, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 55, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+056: 				L[x][y] = min(l2,ix)
+
        __pyx_t_12 = __pyx_v_ix;
+        __pyx_t_10 = __pyx_v_l2;
+        if (((__pyx_t_12 < __pyx_t_10) != 0)) {
+          __pyx_t_14 = __pyx_t_12;
+        } else {
+          __pyx_t_14 = __pyx_t_10;
+        }
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 56, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 56, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      }
+      __pyx_L7:;
+      __pyx_L5_continue:;
+    }
+  }
+
 057:
+
+058: 	return True
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_True);
+  __pyx_r = Py_True;
+  goto __pyx_L0;
+
 059:
+
 060: @cython.boundscheck(False)
+
+061: cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
+
static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) {
+  int __pyx_v_n_rows;
+  int __pyx_v_n_cols;
+  int __pyx_v_x;
+  int __pyx_v_y;
+  double __pyx_v_ix;
+  double __pyx_v_d;
+  double __pyx_v_u1;
+  double __pyx_v_l1;
+  double __pyx_v_u2;
+  double __pyx_v_l2;
+  double __pyx_v_b1;
+  double __pyx_v_b2;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_D;
+  __Pyx_Buffer __pyx_pybuffer_D;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_L;
+  __Pyx_Buffer __pyx_pybuffer_L;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_U;
+  __Pyx_Buffer __pyx_pybuffer_U;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_img;
+  __Pyx_Buffer __pyx_pybuffer_img;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("raster_scan_inv", 0);
+  __pyx_pybuffer_img.pybuffer.buf = NULL;
+  __pyx_pybuffer_img.refcount = 0;
+  __pyx_pybuffernd_img.data = NULL;
+  __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img;
+  __pyx_pybuffer_L.pybuffer.buf = NULL;
+  __pyx_pybuffer_L.refcount = 0;
+  __pyx_pybuffernd_L.data = NULL;
+  __pyx_pybuffernd_L.rcbuffer = &__pyx_pybuffer_L;
+  __pyx_pybuffer_U.pybuffer.buf = NULL;
+  __pyx_pybuffer_U.refcount = 0;
+  __pyx_pybuffernd_U.data = NULL;
+  __pyx_pybuffernd_U.rcbuffer = &__pyx_pybuffer_U;
+  __pyx_pybuffer_D.pybuffer.buf = NULL;
+  __pyx_pybuffer_D.refcount = 0;
+  __pyx_pybuffernd_D.data = NULL;
+  __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1];
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("saliency_mbd.raster_scan_inv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
 062: 	cdef int n_rows
+
 063: 	cdef int n_cols
+
 064:
+
+065: 	n_rows = len(img)
+
  __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_img)); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 65, __pyx_L1_error)
+  __pyx_v_n_rows = __pyx_t_1;
+
+066: 	n_cols = len(img[0])
+
  __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_n_cols = __pyx_t_1;
+
 067:
+
 068: 	cdef int x
+
 069: 	cdef int y
+
 070: 	cdef double ix
+
 071: 	cdef double d
+
 072: 	cdef double u1
+
 073: 	cdef double l1
+
 074: 	cdef double u2
+
 075: 	cdef double l2
+
 076: 	cdef double b1
+
 077: 	cdef double b2
+
 078:
+
+079: 	for x in range(n_rows - 2,1,-1):
+
  for (__pyx_t_3 = (__pyx_v_n_rows - 2); __pyx_t_3 > 1; __pyx_t_3-=1) {
+    __pyx_v_x = __pyx_t_3;
+
+080: 		for y in range(n_cols - 2,1,-1):
+
    for (__pyx_t_4 = (__pyx_v_n_cols - 2); __pyx_t_4 > 1; __pyx_t_4-=1) {
+      __pyx_v_y = __pyx_t_4;
+
 081:
+
+082: 			ix = img[x][y]
+
      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_v_ix = __pyx_t_6;
+
+083: 			d = D[x][y]
+
      __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 83, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_d = __pyx_t_6;
+
 084:
+
+085: 			u1 = U[x+1][y]
+
      __pyx_t_7 = (__pyx_v_x + 1);
+      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_v_u1 = __pyx_t_6;
+
+086: 			l1 = L[x+1][y]
+
      __pyx_t_7 = (__pyx_v_x + 1);
+      __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_l1 = __pyx_t_6;
+
 087:
+
+088: 			u2 = U[x][y+1]
+
      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_7 = (__pyx_v_y + 1);
+      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 88, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 88, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_v_u2 = __pyx_t_6;
+
+089: 			l2 = L[x][y+1]
+
      __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_7 = (__pyx_v_y + 1);
+      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_l2 = __pyx_t_6;
+
 090:
+
+091: 			b1 = max(u1,ix) - min(l1,ix)
+
      __pyx_t_6 = __pyx_v_ix;
+      __pyx_t_8 = __pyx_v_u1;
+      if (((__pyx_t_6 > __pyx_t_8) != 0)) {
+        __pyx_t_9 = __pyx_t_6;
+      } else {
+        __pyx_t_9 = __pyx_t_8;
+      }
+      __pyx_t_6 = __pyx_v_ix;
+      __pyx_t_8 = __pyx_v_l1;
+      if (((__pyx_t_6 < __pyx_t_8) != 0)) {
+        __pyx_t_10 = __pyx_t_6;
+      } else {
+        __pyx_t_10 = __pyx_t_8;
+      }
+      __pyx_v_b1 = (__pyx_t_9 - __pyx_t_10);
+
+092: 			b2 = max(u2,ix) - min(l2,ix)
+
      __pyx_t_10 = __pyx_v_ix;
+      __pyx_t_9 = __pyx_v_u2;
+      if (((__pyx_t_10 > __pyx_t_9) != 0)) {
+        __pyx_t_6 = __pyx_t_10;
+      } else {
+        __pyx_t_6 = __pyx_t_9;
+      }
+      __pyx_t_10 = __pyx_v_ix;
+      __pyx_t_9 = __pyx_v_l2;
+      if (((__pyx_t_10 < __pyx_t_9) != 0)) {
+        __pyx_t_8 = __pyx_t_10;
+      } else {
+        __pyx_t_8 = __pyx_t_9;
+      }
+      __pyx_v_b2 = (__pyx_t_6 - __pyx_t_8);
+
 093:
+
+094: 			if d <= b1 and d <= b2:
+
      __pyx_t_12 = ((__pyx_v_d <= __pyx_v_b1) != 0);
+      if (__pyx_t_12) {
+      } else {
+        __pyx_t_11 = __pyx_t_12;
+        goto __pyx_L8_bool_binop_done;
+      }
+      __pyx_t_12 = ((__pyx_v_d <= __pyx_v_b2) != 0);
+      __pyx_t_11 = __pyx_t_12;
+      __pyx_L8_bool_binop_done:;
+      if (__pyx_t_11) {
+/* … */
+      }
+
+095: 				continue
+
        goto __pyx_L5_continue;
+
+096: 			elif b1 < d and b1 <= b2:
+
      __pyx_t_12 = ((__pyx_v_b1 < __pyx_v_d) != 0);
+      if (__pyx_t_12) {
+      } else {
+        __pyx_t_11 = __pyx_t_12;
+        goto __pyx_L10_bool_binop_done;
+      }
+      __pyx_t_12 = ((__pyx_v_b1 <= __pyx_v_b2) != 0);
+      __pyx_t_11 = __pyx_t_12;
+      __pyx_L10_bool_binop_done:;
+      if (__pyx_t_11) {
+/* … */
+        goto __pyx_L7;
+      }
+
+097: 				D[x][y] = b1
+
        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 97, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+098: 				U[x][y] = max(u1,ix)
+
        __pyx_t_8 = __pyx_v_ix;
+        __pyx_t_6 = __pyx_v_u1;
+        if (((__pyx_t_8 > __pyx_t_6) != 0)) {
+          __pyx_t_10 = __pyx_t_8;
+        } else {
+          __pyx_t_10 = __pyx_t_6;
+        }
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 98, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 98, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+099: 				L[x][y] = min(l1,ix)
+
        __pyx_t_10 = __pyx_v_ix;
+        __pyx_t_8 = __pyx_v_l1;
+        if (((__pyx_t_10 < __pyx_t_8) != 0)) {
+          __pyx_t_6 = __pyx_t_10;
+        } else {
+          __pyx_t_6 = __pyx_t_8;
+        }
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 99, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
 100: 			else:
+
+101: 				D[x][y] = b2
+
      /*else*/ {
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 101, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+102: 				U[x][y] = max(u2,ix)
+
        __pyx_t_6 = __pyx_v_ix;
+        __pyx_t_10 = __pyx_v_u2;
+        if (((__pyx_t_6 > __pyx_t_10) != 0)) {
+          __pyx_t_8 = __pyx_t_6;
+        } else {
+          __pyx_t_8 = __pyx_t_10;
+        }
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 102, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+103: 				L[x][y] = min(l2,ix)
+
        __pyx_t_8 = __pyx_v_ix;
+        __pyx_t_6 = __pyx_v_l2;
+        if (((__pyx_t_8 < __pyx_t_6) != 0)) {
+          __pyx_t_10 = __pyx_t_8;
+        } else {
+          __pyx_t_10 = __pyx_t_6;
+        }
+        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 103, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 103, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      }
+      __pyx_L7:;
+      __pyx_L5_continue:;
+    }
+  }
+
 104:
+
+105: 	return True
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_True);
+  __pyx_r = Py_True;
+  goto __pyx_L0;
+
 106:
+
 107: @cython.boundscheck(False)
+
+108: cdef mbd(np.ndarray[double, ndim=2] img, int num_iters):
+
static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __pyx_v_num_iters) {
+  PyObject *__pyx_v_L = NULL;
+  PyObject *__pyx_v_U = NULL;
+  PyObject *__pyx_v_D = NULL;
+  int __pyx_v_x;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_img;
+  __Pyx_Buffer __pyx_pybuffer_img;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("mbd", 0);
+  __pyx_pybuffer_img.pybuffer.buf = NULL;
+  __pyx_pybuffer_img.refcount = 0;
+  __pyx_pybuffernd_img.data = NULL;
+  __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 108, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1];
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("saliency_mbd.mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF(__pyx_v_L);
+  __Pyx_XDECREF(__pyx_v_U);
+  __Pyx_XDECREF(__pyx_v_D);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
 109:
+
+110: 	L = np.copy(img)
+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_img));
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_L = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+111: 	U = np.copy(img)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_img));
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_U = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+112: 	D = np.full_like(img, 10000000)
+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_full_like); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  __pyx_t_4 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+      __pyx_t_4 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_img), __pyx_int_10000000};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_img), __pyx_int_10000000};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  {
+    __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__pyx_t_2) {
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
+    }
+    __Pyx_INCREF(((PyObject *)__pyx_v_img));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_img));
+    PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, ((PyObject *)__pyx_v_img));
+    __Pyx_INCREF(__pyx_int_10000000);
+    __Pyx_GIVEREF(__pyx_int_10000000);
+    PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_int_10000000);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_D = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+113: 	D[0,:] = 0
+
  __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+/* … */
+  if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__2, __pyx_int_0) < 0)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __pyx_tuple__2 = PyTuple_Pack(2, __pyx_int_0, __pyx_slice_); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+
+114: 	D[-1,:] = 0
+
  if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__3, __pyx_int_0) < 0)) __PYX_ERR(0, 114, __pyx_L1_error)
+/* … */
+  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_neg_1, __pyx_slice_); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+
+115: 	D[:,0] = 0
+
  if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__4, __pyx_int_0) < 0)) __PYX_ERR(0, 115, __pyx_L1_error)
+/* … */
+  __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 115, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+
+116: 	D[:,-1] = 0
+
  if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__5, __pyx_int_0) < 0)) __PYX_ERR(0, 116, __pyx_L1_error)
+/* … */
+  __pyx_tuple__5 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
 117:
+
 118: 	cdef int x
+
+119: 	for x in range(0,num_iters):
+
  __pyx_t_4 = __pyx_v_num_iters;
+  __pyx_t_6 = __pyx_t_4;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_x = __pyx_t_7;
+
+120: 		if x%2 == 1:
+
    __pyx_t_8 = ((__Pyx_mod_long(__pyx_v_x, 2) == 1) != 0);
+    if (__pyx_t_8) {
+/* … */
+      goto __pyx_L5;
+    }
+
+121: 			raster_scan(img,L,U,D)
+
      if (!(likely(((__pyx_v_L) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_L, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error)
+      if (!(likely(((__pyx_v_U) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_U, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error)
+      if (!(likely(((__pyx_v_D) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_D, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error)
+      __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 122: 		else:
+
+123: 			raster_scan_inv(img,L,U,D)
+
    /*else*/ {
+      if (!(likely(((__pyx_v_L) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_L, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error)
+      if (!(likely(((__pyx_v_U) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_U, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error)
+      if (!(likely(((__pyx_v_D) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_D, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error)
+      __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan_inv(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __pyx_L5:;
+  }
+
 124:
+
+125: 	return D
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_D);
+  __pyx_r = __pyx_v_D;
+  goto __pyx_L0;
+
 126:
+
+127: def f(x):
+
/* Python wrapper */
+static PyObject *__pyx_pw_12saliency_mbd_1f(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/
+static PyMethodDef __pyx_mdef_12saliency_mbd_1f = {"f", (PyCFunction)__pyx_pw_12saliency_mbd_1f, METH_O, 0};
+static PyObject *__pyx_pw_12saliency_mbd_1f(PyObject *__pyx_self, PyObject *__pyx_v_x) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("f (wrapper)", 0);
+  __pyx_r = __pyx_pf_12saliency_mbd_f(__pyx_self, ((PyObject *)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) {
+  double __pyx_v_b;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("f", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("saliency_mbd.f", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__15 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_b); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+/* … */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12saliency_mbd_1f, NULL, __pyx_n_s_saliency_mbd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_f, __pyx_t_1) < 0) __PYX_ERR(0, 127, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+128: 	b = 10.0
+
  __pyx_v_b = 10.0;
+
+129: 	return 1.0 / (1.0 + exp(-b*(x - 0.5)))
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble((-__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyFloat_SubtractObjC(__pyx_v_x, __pyx_float_0_5, 0.5, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 129, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5 = (1.0 + exp(__pyx_t_4));
+  if (unlikely(__pyx_t_5 == 0)) {
+    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+    __PYX_ERR(0, 129, __pyx_L1_error)
+  }
+  __pyx_t_3 = PyFloat_FromDouble((1.0 / __pyx_t_5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
 130:
+
 131: @cython.boundscheck(False)
+
+132: cpdef get_saliency_mbd(np.ndarray img,method='b'):
+
static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_img, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd *__pyx_optional_args) {
+  PyObject *__pyx_v_img_mean = NULL;
+  PyObject *__pyx_v_sal = NULL;
+  int __pyx_v_n_rows;
+  int __pyx_v_n_cols;
+  CYTHON_UNUSED int __pyx_v_n_channels;
+  double __pyx_v_img_size;
+  PyObject *__pyx_v_border_thickness = NULL;
+  PyArrayObject *__pyx_v_img_lab = 0;
+  PyObject *__pyx_v_px_left = NULL;
+  PyObject *__pyx_v_px_right = NULL;
+  PyObject *__pyx_v_px_top = NULL;
+  PyObject *__pyx_v_px_bottom = NULL;
+  PyObject *__pyx_v_px_mean_left = NULL;
+  PyObject *__pyx_v_px_mean_right = NULL;
+  PyObject *__pyx_v_px_mean_top = NULL;
+  PyObject *__pyx_v_px_mean_bottom = NULL;
+  PyObject *__pyx_v_cov_left = NULL;
+  PyObject *__pyx_v_cov_right = NULL;
+  PyObject *__pyx_v_cov_top = NULL;
+  PyObject *__pyx_v_cov_bottom = NULL;
+  PyObject *__pyx_v_u_left = NULL;
+  PyObject *__pyx_v_u_right = NULL;
+  PyObject *__pyx_v_u_top = NULL;
+  PyObject *__pyx_v_u_bottom = NULL;
+  PyObject *__pyx_v_u_final = NULL;
+  PyObject *__pyx_v_img_lab_unrolled = NULL;
+  PyObject *__pyx_v_px_mean_left_2 = NULL;
+  PyObject *__pyx_v_px_mean_right_2 = NULL;
+  PyObject *__pyx_v_px_mean_top_2 = NULL;
+  PyObject *__pyx_v_px_mean_bottom_2 = NULL;
+  PyObject *__pyx_v_max_u_left = NULL;
+  PyObject *__pyx_v_max_u_right = NULL;
+  PyObject *__pyx_v_max_u_top = NULL;
+  PyObject *__pyx_v_max_u_bottom = NULL;
+  PyObject *__pyx_v_u_max = NULL;
+  PyObject *__pyx_v_u_max_final = NULL;
+  PyObject *__pyx_v_sal_max = NULL;
+  PyObject *__pyx_v_s = NULL;
+  double __pyx_v_alpha;
+  CYTHON_UNUSED double __pyx_v_delta;
+  PyObject *__pyx_v_xv = NULL;
+  PyObject *__pyx_v_yv = NULL;
+  PyObject *__pyx_v_w = NULL;
+  PyObject *__pyx_v_h = NULL;
+  double __pyx_v_w2;
+  double __pyx_v_h2;
+  PyObject *__pyx_v_C = NULL;
+  PyObject *__pyx_v_fv = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_saliency_mbd", 0);
+  if (__pyx_optional_args) {
+  }
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_img_mean);
+  __Pyx_XDECREF(__pyx_v_sal);
+  __Pyx_XDECREF(__pyx_v_border_thickness);
+  __Pyx_XDECREF((PyObject *)__pyx_v_img_lab);
+  __Pyx_XDECREF(__pyx_v_px_left);
+  __Pyx_XDECREF(__pyx_v_px_right);
+  __Pyx_XDECREF(__pyx_v_px_top);
+  __Pyx_XDECREF(__pyx_v_px_bottom);
+  __Pyx_XDECREF(__pyx_v_px_mean_left);
+  __Pyx_XDECREF(__pyx_v_px_mean_right);
+  __Pyx_XDECREF(__pyx_v_px_mean_top);
+  __Pyx_XDECREF(__pyx_v_px_mean_bottom);
+  __Pyx_XDECREF(__pyx_v_cov_left);
+  __Pyx_XDECREF(__pyx_v_cov_right);
+  __Pyx_XDECREF(__pyx_v_cov_top);
+  __Pyx_XDECREF(__pyx_v_cov_bottom);
+  __Pyx_XDECREF(__pyx_v_u_left);
+  __Pyx_XDECREF(__pyx_v_u_right);
+  __Pyx_XDECREF(__pyx_v_u_top);
+  __Pyx_XDECREF(__pyx_v_u_bottom);
+  __Pyx_XDECREF(__pyx_v_u_final);
+  __Pyx_XDECREF(__pyx_v_img_lab_unrolled);
+  __Pyx_XDECREF(__pyx_v_px_mean_left_2);
+  __Pyx_XDECREF(__pyx_v_px_mean_right_2);
+  __Pyx_XDECREF(__pyx_v_px_mean_top_2);
+  __Pyx_XDECREF(__pyx_v_px_mean_bottom_2);
+  __Pyx_XDECREF(__pyx_v_max_u_left);
+  __Pyx_XDECREF(__pyx_v_max_u_right);
+  __Pyx_XDECREF(__pyx_v_max_u_top);
+  __Pyx_XDECREF(__pyx_v_max_u_bottom);
+  __Pyx_XDECREF(__pyx_v_u_max);
+  __Pyx_XDECREF(__pyx_v_u_max_final);
+  __Pyx_XDECREF(__pyx_v_sal_max);
+  __Pyx_XDECREF(__pyx_v_s);
+  __Pyx_XDECREF(__pyx_v_xv);
+  __Pyx_XDECREF(__pyx_v_yv);
+  __Pyx_XDECREF(__pyx_v_w);
+  __Pyx_XDECREF(__pyx_v_h);
+  __Pyx_XDECREF(__pyx_v_C);
+  __Pyx_XDECREF(__pyx_v_fv);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_img = 0;
+  PyObject *__pyx_v_method = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_saliency_mbd (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_img,&__pyx_n_s_method,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)__pyx_n_s_b);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_img)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 132, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_img = ((PyArrayObject *)values[0]);
+    __pyx_v_method = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 132, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 132, __pyx_L1_error)
+  __pyx_r = __pyx_pf_12saliency_mbd_2get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_saliency_mbd", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2.__pyx_n = 1;
+  __pyx_t_2.method = __pyx_v_method;
+  __pyx_t_1 = __pyx_f_12saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
 133: 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
+
+134: 	img_mean = np.mean(img,axis=(2))
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_img));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_img));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_img));
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_int_2) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_img_mean = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+135: 	sal = mbd(img_mean,2)
+
  if (!(likely(((__pyx_v_img_mean) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_img_mean, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 135, __pyx_L1_error)
+  __pyx_t_4 = __pyx_f_12saliency_mbd_mbd(((PyArrayObject *)__pyx_v_img_mean), 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_sal = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 136:
+
+137: 	cdef int n_rows = img.shape[0]
+
  __pyx_v_n_rows = (__pyx_v_img->dimensions[0]);
+
+138: 	cdef int n_cols = img.shape[1]
+
  __pyx_v_n_cols = (__pyx_v_img->dimensions[1]);
+
+139: 	cdef int n_channels = img.shape[2]
+
  __pyx_v_n_channels = (__pyx_v_img->dimensions[2]);
+
+140: 	cdef double img_size = sqrt(n_rows * n_cols)
+
  __pyx_v_img_size = sqrt((__pyx_v_n_rows * __pyx_v_n_cols));
+
+141: 	border_thickness = int(floor(0.1 * img_size))
+
  __pyx_t_4 = __Pyx_PyInt_FromDouble(floor((0.1 * __pyx_v_img_size))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_border_thickness = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 142:
+
+143: 	cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img))
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_skimage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_color); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_rgb2lab); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_img));
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 143, __pyx_L1_error)
+  __pyx_v_img_lab = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
 144:
+
+145: 	px_left = img_lab[0:border_thickness,:,:]
+
  __pyx_t_4 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_slice_);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_px_left = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+146: 	px_right = img_lab[n_rows - border_thickness-1:-1,:,:]
+
  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_v_border_thickness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PySlice_New(__pyx_t_4, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_slice_);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_px_right = __pyx_t_3;
+  __pyx_t_3 = 0;
+
 147:
+
+148: 	px_top = img_lab[:,0:border_thickness,:]
+
  __pyx_t_3 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_slice_);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_px_top = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+149: 	px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:]
+
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_v_border_thickness); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PySlice_New(__pyx_t_3, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_slice_);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_px_bottom = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 150:
+
+151: 	px_mean_left = np.mean(px_left,axis=(0,1))
+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_v_px_left);
+  __Pyx_GIVEREF(__pyx_v_px_left);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_px_left);
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 151, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_px_mean_left = __pyx_t_2;
+  __pyx_t_2 = 0;
+/* … */
+  __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+
+152: 	px_mean_right = np.mean(px_right,axis=(0,1))
+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_px_right);
+  __Pyx_GIVEREF(__pyx_v_px_right);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_px_right);
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 152, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_px_mean_right = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+153: 	px_mean_top = np.mean(px_top,axis=(0,1))
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_v_px_top);
+  __Pyx_GIVEREF(__pyx_v_px_top);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_px_top);
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 153, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_px_mean_top = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+154: 	px_mean_bottom = np.mean(px_bottom,axis=(0,1))
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_v_px_bottom);
+  __Pyx_GIVEREF(__pyx_v_px_bottom);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_px_bottom);
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 154, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_px_mean_bottom = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 155:
+
 156:
+
+157: 	px_left = px_left.reshape((n_cols*border_thickness,3))
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_px_left, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+158: 	px_right = px_right.reshape((n_cols*border_thickness,3))
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_px_right, __pyx_t_4);
+  __pyx_t_4 = 0;
+
 159:
+
+160: 	px_top = px_top.reshape((n_rows*border_thickness,3))
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_px_top, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+161: 	px_bottom = px_bottom.reshape((n_rows*border_thickness,3))
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_px_bottom, __pyx_t_4);
+  __pyx_t_4 = 0;
+
 162:
+
+163: 	cov_left = np.cov(px_left.T)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_cov_left = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+164: 	cov_right = np.cov(px_right.T)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_cov_right = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 165:
+
+166: 	cov_top = np.cov(px_top.T)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_cov_top = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+167: 	cov_bottom = np.cov(px_bottom.T)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_cov_bottom = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 168:
+
+169: 	cov_left = np.linalg.inv(cov_left)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_left) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_left);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_cov_left, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+170: 	cov_right = np.linalg.inv(cov_right)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_right) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_right);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_cov_right, __pyx_t_4);
+  __pyx_t_4 = 0;
+
 171:
+
+172: 	cov_top = np.linalg.inv(cov_top)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_top) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_top);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_cov_top, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+173: 	cov_bottom = np.linalg.inv(cov_bottom)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_bottom);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_cov_bottom, __pyx_t_4);
+  __pyx_t_4 = 0;
+
 174:
+
 175:
+
+176: 	u_left = np.zeros(sal.shape)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_u_left = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+177: 	u_right = np.zeros(sal.shape)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_u_right = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+178: 	u_top = np.zeros(sal.shape)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_u_top = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+179: 	u_bottom = np.zeros(sal.shape)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_u_bottom = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 180:
+
+181: 	u_final = np.zeros(sal.shape)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_u_final = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+182: 	img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_img_lab), __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(((__pyx_v_img_lab->dimensions[0]) * (__pyx_v_img_lab->dimensions[1]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_1)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 182, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__pyx_t_2) {
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_t_3);
+    __Pyx_INCREF(__pyx_int_3);
+    __Pyx_GIVEREF(__pyx_int_3);
+    PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_int_3);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_img_lab_unrolled = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 183:
+
+184: 	px_mean_left_2 = np.zeros((1,3))
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_tuple__7);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_px_mean_left_2 = __pyx_t_4;
+  __pyx_t_4 = 0;
+/* … */
+  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_3); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+
+185: 	px_mean_left_2[0,:] = px_mean_left
+
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_left_2, __pyx_tuple__2, __pyx_v_px_mean_left) < 0)) __PYX_ERR(0, 185, __pyx_L1_error)
+
 186:
+
+187: 	u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left)
+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_scipy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_spatial); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_distance); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_cdist); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_v_img_lab_unrolled);
+  __Pyx_GIVEREF(__pyx_v_img_lab_unrolled);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_img_lab_unrolled);
+  __Pyx_INCREF(__pyx_v_px_mean_left_2);
+  __Pyx_GIVEREF(__pyx_v_px_mean_left_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_px_mean_left_2);
+  __Pyx_INCREF(__pyx_n_s_mahalanobis);
+  __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
+  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_n_s_mahalanobis);
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_left) < 0) __PYX_ERR(0, 187, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+188: 	u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1]))
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_5);
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3);
+  __pyx_t_3 = 0;
+
 189:
+
+190: 	px_mean_right_2 = np.zeros((1,3))
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_tuple__7);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_px_mean_right_2 = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+191: 	px_mean_right_2[0,:] = px_mean_right
+
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_right_2, __pyx_tuple__2, __pyx_v_px_mean_right) < 0)) __PYX_ERR(0, 191, __pyx_L1_error)
+
 192:
+
+193: 	u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right)
+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_scipy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_spatial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_distance); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cdist); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_v_img_lab_unrolled);
+  __Pyx_GIVEREF(__pyx_v_img_lab_unrolled);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_img_lab_unrolled);
+  __Pyx_INCREF(__pyx_v_px_mean_right_2);
+  __Pyx_GIVEREF(__pyx_v_px_mean_right_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_px_mean_right_2);
+  __Pyx_INCREF(__pyx_n_s_mahalanobis);
+  __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_n_s_mahalanobis);
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_right) < 0) __PYX_ERR(0, 193, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+194: 	u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1]))
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
+  __pyx_t_3 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5);
+  __pyx_t_5 = 0;
+
 195:
+
+196: 	px_mean_top_2 = np.zeros((1,3))
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_tuple__7);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_px_mean_top_2 = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+197: 	px_mean_top_2[0,:] = px_mean_top
+
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_top_2, __pyx_tuple__2, __pyx_v_px_mean_top) < 0)) __PYX_ERR(0, 197, __pyx_L1_error)
+
 198:
+
+199: 	u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top)
+
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_scipy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_spatial); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_distance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_cdist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(__pyx_v_img_lab_unrolled);
+  __Pyx_GIVEREF(__pyx_v_img_lab_unrolled);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_img_lab_unrolled);
+  __Pyx_INCREF(__pyx_v_px_mean_top_2);
+  __Pyx_GIVEREF(__pyx_v_px_mean_top_2);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_px_mean_top_2);
+  __Pyx_INCREF(__pyx_n_s_mahalanobis);
+  __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
+  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_n_s_mahalanobis);
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_top) < 0) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2);
+  __pyx_t_2 = 0;
+
+200: 	u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1]))
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __pyx_t_5 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2);
+  __pyx_t_2 = 0;
+
 201:
+
+202: 	px_mean_bottom_2 = np.zeros((1,3))
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_tuple__7);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_px_mean_bottom_2 = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+203: 	px_mean_bottom_2[0,:] = px_mean_bottom
+
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_bottom_2, __pyx_tuple__2, __pyx_v_px_mean_bottom) < 0)) __PYX_ERR(0, 203, __pyx_L1_error)
+
 204:
+
+205: 	u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom)
+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_scipy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_spatial); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_distance); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_cdist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_img_lab_unrolled);
+  __Pyx_GIVEREF(__pyx_v_img_lab_unrolled);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_img_lab_unrolled);
+  __Pyx_INCREF(__pyx_v_px_mean_bottom_2);
+  __Pyx_GIVEREF(__pyx_v_px_mean_bottom_2);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_px_mean_bottom_2);
+  __Pyx_INCREF(__pyx_n_s_mahalanobis);
+  __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
+  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_mahalanobis);
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_bottom) < 0) __PYX_ERR(0, 205, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+206: 	u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1]))
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4);
+  __pyx_t_4 = 0;
+
 207:
+
+208: 	max_u_left = np.max(u_left)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_left) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_left);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_max_u_left = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+209: 	max_u_right = np.max(u_right)
+
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_right) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_right);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_max_u_right = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+210: 	max_u_top = np.max(u_top)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_top) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_top);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_max_u_top = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+211: 	max_u_bottom = np.max(u_bottom)
+
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_bottom);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_max_u_bottom = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 212:
+
+213: 	u_left = u_left / max_u_left
+
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_left, __pyx_v_max_u_left); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+214: 	u_right = u_right / max_u_right
+
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_right, __pyx_v_max_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+215: 	u_top = u_top / max_u_top
+
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_top, __pyx_v_max_u_top); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+216: 	u_bottom = u_bottom / max_u_bottom
+
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_bottom, __pyx_v_max_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4);
+  __pyx_t_4 = 0;
+
 217:
+
+218: 	u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_maximum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_maximum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_maximum); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_8, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_8)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right};
+    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right};
+    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
+  } else
+  #endif
+  {
+    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    if (__pyx_t_7) {
+      __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_u_left);
+    __Pyx_GIVEREF(__pyx_v_u_left);
+    PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_v_u_left);
+    __Pyx_INCREF(__pyx_v_u_right);
+    __Pyx_GIVEREF(__pyx_v_u_right);
+    PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_right);
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_8 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    if (__pyx_t_8) {
+      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_t_3);
+    __Pyx_INCREF(__pyx_v_u_top);
+    __Pyx_GIVEREF(__pyx_v_u_top);
+    PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_top);
+    __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_5)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    if (__pyx_t_2) {
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_t_1);
+    __Pyx_INCREF(__pyx_v_u_bottom);
+    __Pyx_GIVEREF(__pyx_v_u_bottom);
+    PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_bottom);
+    __pyx_t_1 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_u_max = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 219:
+
+220: 	u_final = (u_left + u_right + u_top + u_bottom) - u_max
+
  __pyx_t_4 = PyNumber_Add(__pyx_v_u_left, __pyx_v_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_v_u_top); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_v_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_v_u_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF_SET(__pyx_v_u_final, __pyx_t_5);
+  __pyx_t_5 = 0;
+
 221:
+
+222: 	u_max_final = np.max(u_final)
+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_9, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_u_final) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_u_final);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __pyx_v_u_max_final = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+223: 	sal_max = np.max(sal)
+
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __pyx_t_9 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_9)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_sal_max = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+224: 	sal = sal / sal_max + u_final / u_max_final
+
  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_v_sal_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_final, __pyx_v_u_max_final); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_9 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_9);
+  __pyx_t_9 = 0;
+
 225:
+
 226: 	#postprocessing
+
 227:
+
 228: 	# apply centredness map
+
+229: 	sal = sal / np.max(sal)
+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __pyx_t_9 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_5);
+  __pyx_t_5 = 0;
+
 230:
+
+231: 	s = np.mean(sal)
+
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __pyx_t_9 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_9)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_s = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+232: 	cdef double alpha = 50.0
+
  __pyx_v_alpha = 50.0;
+
+233: 	cdef double delta = alpha * sqrt(s)
+
  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_s); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 233, __pyx_L1_error)
+  __pyx_v_delta = (__pyx_v_alpha * sqrt(__pyx_t_10));
+
 234:
+
+235: 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))
+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_meshgrid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_arange); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_9, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_9)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2};
+    __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2};
+    __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_8 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    if (__pyx_t_1) {
+      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); __pyx_t_1 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_6, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_6, __pyx_t_2);
+    __pyx_t_4 = 0;
+    __pyx_t_2 = 0;
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
+    PyObject* sequence = __pyx_t_5;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 235, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_9 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_8 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_9);
+    __Pyx_INCREF(__pyx_t_8);
+    #else
+    __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    #endif
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext;
+    index = 0; __pyx_t_9 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_9);
+    index = 1; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_8);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_t_11 = NULL;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_11 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_v_xv = __pyx_t_9;
+  __pyx_t_9 = 0;
+  __pyx_v_yv = __pyx_t_8;
+  __pyx_t_8 = 0;
+
+236: 	(w,h) = sal.shape
+
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
+    PyObject* sequence = __pyx_t_5;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 236, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_8 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_9 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_8);
+    __Pyx_INCREF(__pyx_t_9);
+    #else
+    __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    #endif
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext;
+    index = 0; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_8);
+    index = 1; __pyx_t_9 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_9);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 236, __pyx_L1_error)
+    __pyx_t_11 = NULL;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    goto __pyx_L6_unpacking_done;
+    __pyx_L5_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_11 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 236, __pyx_L1_error)
+    __pyx_L6_unpacking_done:;
+  }
+  __pyx_v_w = __pyx_t_8;
+  __pyx_t_8 = 0;
+  __pyx_v_h = __pyx_t_9;
+  __pyx_t_9 = 0;
+
+237: 	cdef double w2 = w/2.0
+
  __pyx_t_5 = __Pyx_PyFloat_DivideObjC(__pyx_v_w, __pyx_float_2_0, 2.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_w2 = __pyx_t_10;
+
+238: 	cdef double h2 = h/2.0
+
  __pyx_t_5 = __Pyx_PyFloat_DivideObjC(__pyx_v_h, __pyx_float_2_0, 2.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_h2 = __pyx_t_10;
+
 239:
+
+240: 	C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2))
+
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = PyNumber_Subtract(__pyx_v_xv, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2};
+    __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2};
+    __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__pyx_t_2) {
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_t_1);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_int_2);
+    __pyx_t_1 = 0;
+    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyNumber_Subtract(__pyx_v_yv, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_1)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_2);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2);
+    __pyx_t_2 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyNumber_Add(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_8, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_9 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_9)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_1, __pyx_int_2};
+    __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_1, __pyx_int_2};
+    __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__pyx_t_9) {
+      __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_1);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2);
+    __pyx_t_1 = 0;
+    __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_9 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_9)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_1)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (__pyx_t_9) {
+      __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_9); __pyx_t_9 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_7);
+    PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_t_7);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_int_2);
+    __pyx_t_7 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyFloat_FromDouble(sqrt(__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_SubtractCObj(__pyx_int_1, __pyx_t_4, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_C = __pyx_t_1;
+  __pyx_t_1 = 0;
+
 241:
+
+242: 	sal = sal * C
+
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_sal, __pyx_v_C); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_1);
+  __pyx_t_1 = 0;
+
 243:
+
+244: 	fv = np.vectorize(f)
+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_vectorize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_8 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_8)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_8, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_fv = __pyx_t_1;
+  __pyx_t_1 = 0;
+
 245:
+
+246: 	sal = sal / np.max(sal)
+
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4);
+  __pyx_t_4 = 0;
+
 247:
+
+248: 	sal = fv(sal)
+
  __Pyx_INCREF(__pyx_v_fv);
+  __pyx_t_1 = __pyx_v_fv; __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4);
+  __pyx_t_4 = 0;
+
 249:
+
+250: 	return sal* 255.0
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
diff --git a/perception/tasks/segmentation/saliency_detection/saliency_mbd.py b/perception/tasks/segmentation/saliency_detection/saliency_mbd.py deleted file mode 100644 index c5c4a52..0000000 --- a/perception/tasks/segmentation/saliency_detection/saliency_mbd.py +++ /dev/null @@ -1,236 +0,0 @@ -import math -import sys -import operator -import networkx as nx -import numpy as np -import scipy.spatial.distance -import scipy.signal -import skimage -import skimage.io -from skimage.segmentation import slic -from skimage.util import img_as_float -from scipy.optimize import minimize - -def raster_scan(img,L,U,D): - n_rows = len(img) - n_cols = len(img[0]) - - for x in range(1,n_rows - 1): - for y in range(1,n_cols - 1): - ix = img[x][y] - d = D[x][y] - - u1 = U[x-1][y] - l1 = L[x-1][y] - - u2 = U[x][y-1] - l2 = L[x][y-1] - - b1 = max(u1,ix) - min(l1,ix) - b2 = max(u2,ix) - min(l2,ix) - - if d <= b1 and d <= b2: - continue - elif b1 < d and b1 <= b2: - D[x][y] = b1 - U[x][y] = max(u1,ix) - L[x][y] = min(l1,ix) - else: - D[x][y] = b2 - U[x][y] = max(u2,ix) - L[x][y] = min(l2,ix) - - return True - -def raster_scan_inv(img,L,U,D): - n_rows = len(img) - n_cols = len(img[0]) - - for x in range(n_rows - 2,1,-1): - for y in range(n_cols - 2,1,-1): - - ix = img[x][y] - d = D[x][y] - - u1 = U[x+1][y] - l1 = L[x+1][y] - - u2 = U[x][y+1] - l2 = L[x][y+1] - - b1 = max(u1,ix) - min(l1,ix) - b2 = max(u2,ix) - min(l2,ix) - - if d <= b1 and d <= b2: - continue - elif b1 < d and b1 <= b2: - D[x][y] = b1 - U[x][y] = max(u1,ix) - L[x][y] = min(l1,ix) - else: - D[x][y] = b2 - U[x][y] = max(u2,ix) - L[x][y] = min(l2,ix) - - return True - -def mbd(img, num_iters): - - if len(img.shape) != 2: - print('did not get 2d np array to fast mbd') - return None - if (img.shape[0] <= 3 or img.shape[1] <= 3): - print('image is too small') - return None - - L = np.copy(img) - U = np.copy(img) - D = float('Inf') * np.ones(img.shape) - D[0,:] = 0 - D[-1,:] = 0 - D[:,0] = 0 - D[:,-1] = 0 - - # unfortunately, iterating over numpy arrays is very slow - img_list = img.tolist() - L_list = L.tolist() - U_list = U.tolist() - D_list = D.tolist() - - for x in range(0,num_iters): - if x%2 == 1: - raster_scan(img_list,L_list,U_list,D_list) - else: - raster_scan_inv(img_list,L_list,U_list,D_list) - - return np.array(D_list) - - -def get_saliency_mbd(img,method='b'): - - # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS - img_mean = np.mean(img,axis=(2)) - sal = mbd(img_mean,2) - - if method == 'b': - # get the background map - - # paper uses 30px for an image of size 300px, so we use 10% - (n_rows,n_cols,n_channels) = img.shape - img_size = math.sqrt(n_rows * n_cols) - border_thickness = int(math.floor(0.1 * img_size)) - - img_lab = img_as_float(skimage.color.rgb2lab(img)) - - px_left = img_lab[0:border_thickness,:,:] - px_right = img_lab[n_rows - border_thickness-1:-1,:,:] - - px_top = img_lab[:,0:border_thickness,:] - px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] - - px_mean_left = np.mean(px_left,axis=(0,1)) - px_mean_right = np.mean(px_right,axis=(0,1)) - px_mean_top = np.mean(px_top,axis=(0,1)) - px_mean_bottom = np.mean(px_bottom,axis=(0,1)) - - - px_left = px_left.reshape((n_cols*border_thickness,3)) - px_right = px_right.reshape((n_cols*border_thickness,3)) - - px_top = px_top.reshape((n_rows*border_thickness,3)) - px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) - - cov_left = np.cov(px_left.T) - cov_right = np.cov(px_right.T) - - cov_top = np.cov(px_top.T) - cov_bottom = np.cov(px_bottom.T) - - cov_left = np.linalg.inv(cov_left) - cov_right = np.linalg.inv(cov_right) - - cov_top = np.linalg.inv(cov_top) - cov_bottom = np.linalg.inv(cov_bottom) - - - u_left = np.zeros(sal.shape) - u_right = np.zeros(sal.shape) - u_top = np.zeros(sal.shape) - u_bottom = np.zeros(sal.shape) - - u_final = np.zeros(sal.shape) - img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) - - px_mean_left_2 = np.zeros((1,3)) - px_mean_left_2[0,:] = px_mean_left - - u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) - u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) - - px_mean_right_2 = np.zeros((1,3)) - px_mean_right_2[0,:] = px_mean_right - - u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) - u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) - - px_mean_top_2 = np.zeros((1,3)) - px_mean_top_2[0,:] = px_mean_top - - u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) - u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) - - px_mean_bottom_2 = np.zeros((1,3)) - px_mean_bottom_2[0,:] = px_mean_bottom - - u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) - u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) - - max_u_left = np.max(u_left) - max_u_right = np.max(u_right) - max_u_top = np.max(u_top) - max_u_bottom = np.max(u_bottom) - - u_left = u_left / max_u_left - u_right = u_right / max_u_right - u_top = u_top / max_u_top - u_bottom = u_bottom / max_u_bottom - - u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) - - u_final = (u_left + u_right + u_top + u_bottom) - u_max - - u_max_final = np.max(u_final) - sal_max = np.max(sal) - sal = sal / sal_max + u_final / u_max_final - - #postprocessing - - # apply centredness map - sal = sal / np.max(sal) - - s = np.mean(sal) - alpha = 50.0 - delta = alpha * math.sqrt(s) - - xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) - (w,h) = sal.shape - w2 = w/2.0 - h2 = h/2.0 - - C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / math.sqrt(np.power(w2,2) + np.power(h2,2)) - - sal = sal * C - - #increase bg/fg contrast - - def f(x): - b = 10.0 - return 1.0 / (1.0 + math.exp(-b*(x - 0.5))) - - fv = np.vectorize(f) - - sal = sal / np.max(sal) - - sal = fv(sal) - - return sal* 255.0 \ No newline at end of file diff --git a/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx b/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx new file mode 100644 index 0000000..b14cd85 --- /dev/null +++ b/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx @@ -0,0 +1,250 @@ +import sys +import numpy as np +cimport numpy as np +import scipy.spatial.distance +import skimage +import skimage.io +from skimage.util import img_as_float +from scipy.optimize import minimize +cimport cython +from libc.math cimport exp, floor, sqrt + +np.import_array() + +@cython.boundscheck(False) +cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): + cdef int n_rows + cdef int n_cols + + n_rows = len(img) + n_cols = len(img[0]) + + cdef int x + cdef int y + cdef double ix + cdef double d + cdef double u1 + cdef double l1 + cdef double u2 + cdef double l2 + cdef double b1 + cdef double b2 + + for x in range(1,n_rows - 1): + for y in range(1,n_cols - 1): + ix = img[x][y] + d = D[x][y] + + u1 = U[x-1][y] + l1 = L[x-1][y] + + u2 = U[x][y-1] + l2 = L[x][y-1] + + b1 = max(u1,ix) - min(l1,ix) + b2 = max(u2,ix) - min(l2,ix) + + if d <= b1 and d <= b2: + continue + elif b1 < d and b1 <= b2: + D[x][y] = b1 + U[x][y] = max(u1,ix) + L[x][y] = min(l1,ix) + else: + D[x][y] = b2 + U[x][y] = max(u2,ix) + L[x][y] = min(l2,ix) + + return True + +@cython.boundscheck(False) +cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): + cdef int n_rows + cdef int n_cols + + n_rows = len(img) + n_cols = len(img[0]) + + cdef int x + cdef int y + cdef double ix + cdef double d + cdef double u1 + cdef double l1 + cdef double u2 + cdef double l2 + cdef double b1 + cdef double b2 + + for x in range(n_rows - 2,1,-1): + for y in range(n_cols - 2,1,-1): + + ix = img[x][y] + d = D[x][y] + + u1 = U[x+1][y] + l1 = L[x+1][y] + + u2 = U[x][y+1] + l2 = L[x][y+1] + + b1 = max(u1,ix) - min(l1,ix) + b2 = max(u2,ix) - min(l2,ix) + + if d <= b1 and d <= b2: + continue + elif b1 < d and b1 <= b2: + D[x][y] = b1 + U[x][y] = max(u1,ix) + L[x][y] = min(l1,ix) + else: + D[x][y] = b2 + U[x][y] = max(u2,ix) + L[x][y] = min(l2,ix) + + return True + +@cython.boundscheck(False) +cdef mbd(np.ndarray[double, ndim=2] img, int num_iters): + + L = np.copy(img) + U = np.copy(img) + D = np.full_like(img, 10000000) + D[0,:] = 0 + D[-1,:] = 0 + D[:,0] = 0 + D[:,-1] = 0 + + cdef int x + for x in range(0,num_iters): + if x%2 == 1: + raster_scan(img,L,U,D) + else: + raster_scan_inv(img,L,U,D) + + return D + +def f(x): + b = 10.0 + return 1.0 / (1.0 + exp(-b*(x - 0.5))) + +@cython.boundscheck(False) +cpdef get_saliency_mbd(np.ndarray img,method='b'): + # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + img_mean = np.mean(img,axis=(2)) + sal = mbd(img_mean,2) + + cdef int n_rows = img.shape[0] + cdef int n_cols = img.shape[1] + cdef int n_channels = img.shape[2] + cdef double img_size = sqrt(n_rows * n_cols) + border_thickness = int(floor(0.1 * img_size)) + + cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) + + px_left = img_lab[0:border_thickness,:,:] + px_right = img_lab[n_rows - border_thickness-1:-1,:,:] + + px_top = img_lab[:,0:border_thickness,:] + px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] + + px_mean_left = np.mean(px_left,axis=(0,1)) + px_mean_right = np.mean(px_right,axis=(0,1)) + px_mean_top = np.mean(px_top,axis=(0,1)) + px_mean_bottom = np.mean(px_bottom,axis=(0,1)) + + + px_left = px_left.reshape((n_cols*border_thickness,3)) + px_right = px_right.reshape((n_cols*border_thickness,3)) + + px_top = px_top.reshape((n_rows*border_thickness,3)) + px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) + + cov_left = np.cov(px_left.T) + cov_right = np.cov(px_right.T) + + cov_top = np.cov(px_top.T) + cov_bottom = np.cov(px_bottom.T) + + cov_left = np.linalg.inv(cov_left) + cov_right = np.linalg.inv(cov_right) + + cov_top = np.linalg.inv(cov_top) + cov_bottom = np.linalg.inv(cov_bottom) + + + u_left = np.zeros(sal.shape) + u_right = np.zeros(sal.shape) + u_top = np.zeros(sal.shape) + u_bottom = np.zeros(sal.shape) + + u_final = np.zeros(sal.shape) + img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) + + px_mean_left_2 = np.zeros((1,3)) + px_mean_left_2[0,:] = px_mean_left + + u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) + u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) + + px_mean_right_2 = np.zeros((1,3)) + px_mean_right_2[0,:] = px_mean_right + + u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) + u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) + + px_mean_top_2 = np.zeros((1,3)) + px_mean_top_2[0,:] = px_mean_top + + u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) + u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) + + px_mean_bottom_2 = np.zeros((1,3)) + px_mean_bottom_2[0,:] = px_mean_bottom + + u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) + u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) + + max_u_left = np.max(u_left) + max_u_right = np.max(u_right) + max_u_top = np.max(u_top) + max_u_bottom = np.max(u_bottom) + + u_left = u_left / max_u_left + u_right = u_right / max_u_right + u_top = u_top / max_u_top + u_bottom = u_bottom / max_u_bottom + + u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) + + u_final = (u_left + u_right + u_top + u_bottom) - u_max + + u_max_final = np.max(u_final) + sal_max = np.max(sal) + sal = sal / sal_max + u_final / u_max_final + + #postprocessing + + # apply centredness map + sal = sal / np.max(sal) + + s = np.mean(sal) + cdef double alpha = 50.0 + cdef double delta = alpha * sqrt(s) + + xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) + (w,h) = sal.shape + cdef double w2 = w/2.0 + cdef double h2 = h/2.0 + + C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) + + sal = sal * C + + fv = np.vectorize(f) + + sal = sal / np.max(sal) + + sal = fv(sal) + + return sal* 255.0 \ No newline at end of file diff --git a/perception/tasks/segmentation/saliency_detection/setup.py b/perception/tasks/segmentation/saliency_detection/setup.py new file mode 100644 index 0000000..c2c4e91 --- /dev/null +++ b/perception/tasks/segmentation/saliency_detection/setup.py @@ -0,0 +1,8 @@ +from distutils.core import Extension, setup +from Cython.Build import cythonize +import numpy +# define an extension that will be cythonized and compiled +ext = Extension(name="saliency_mbd", sources=["saliency_mbd.pyx"]) +setup(ext_modules=cythonize(ext), +include_dirs=[numpy.get_include()]) + \ No newline at end of file From ad9dbf648397a7ba4805e622d2cd2c4f0febd822 Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sun, 7 Feb 2021 17:16:52 -0800 Subject: [PATCH 17/43] Removed Internal Resizing --- perception/tasks/segmentation/saliency_detection/MBD.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/perception/tasks/segmentation/saliency_detection/MBD.py b/perception/tasks/segmentation/saliency_detection/MBD.py index 510006c..c043e5d 100644 --- a/perception/tasks/segmentation/saliency_detection/MBD.py +++ b/perception/tasks/segmentation/saliency_detection/MBD.py @@ -10,10 +10,6 @@ def __init__(self, **kwargs): super().__init__(lower_bound=((0,255), 10)) def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): - width = int(frame.shape[1] * 0.7) - height = int(frame.shape[0] * 0.7) - dsize = (width, height) - frame = cv.resize(frame, dsize) mbd = get_saliency_mbd(frame).astype('uint8') ret3,th3 = cv.threshold(mbd,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU) return th3, [frame, mbd, th3] From e95956f5009a2b31b5fca46a1b667197e5ad133b Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sun, 7 Feb 2021 17:30:56 -0800 Subject: [PATCH 18/43] add bitwise and for saliency and knn --- perception/__init__.py | 6 +++++- perception/tasks/segmentation/COMB_SAL_BG.py | 22 ++++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 perception/tasks/segmentation/COMB_SAL_BG.py diff --git a/perception/__init__.py b/perception/__init__.py index 3ffbb71..1fa218d 100644 --- a/perception/__init__.py +++ b/perception/__init__.py @@ -4,6 +4,8 @@ import perception.tasks.gate.GateSegmentationAlgoB as GateSegB import perception.tasks.gate.GateSegmentationAlgoC as GateSegC import perception.tasks.segmentation.saliency_detection.MBD as MBD +from perception.tasks.segmentation.COMB_SAL_BG import COMB_SAL_BG +import perception.vis.TestTasks.BackgroundRemoval as BackgroundRemoval # import perception.tasks as tasks ALGOS = { @@ -12,5 +14,7 @@ 'gatesegA': GateSegA.GateSegmentationAlgoA, 'gatesegB': GateSegB.GateSegmentationAlgoB, 'gatesegC': GateSegC.GateSegmentationAlgoC, - 'MBD': MBD.MBD + 'MBD': MBD.MBD, + 'bg-rm': BackgroundRemoval.BackgroundRemoval, + 'combined': COMB_SAL_BG } diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py new file mode 100644 index 0000000..92fb9ff --- /dev/null +++ b/perception/tasks/segmentation/COMB_SAL_BG.py @@ -0,0 +1,22 @@ +import cv2 as cv +import numpy as np +from perception.tasks.TaskPerceiver import TaskPerceiver +from typing import Dict +from perception.tasks.segmentation.saliency_detection.MBD import MBD +from perception.vis.TestTasks.BackgroundRemoval import BackgroundRemoval + +class COMB_SAL_BG(TaskPerceiver): + def __init__(self, **kwargs): + super().__init__(blur = ((0, 10), 2), lamda = ((0,10),1), lower_bound=((0,255), 10)) + self.sal = MBD() + self.bg = BackgroundRemoval() + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + sal = self.sal.analyze(frame, debug, slider_vals=slider_vals) + bg = self.bg.analyze(frame,debug, slider_vals=slider_vals) + # print(type(sal), type(bg)) + ret = np.zeros(sal[0].shape) + cv.bitwise_and(sal[0],bg[0], dst=ret) + # small = min(cv.s) + # print (type(ret)) + return frame, [frame, sal[0], bg[0], ret] \ No newline at end of file From e06c29a0bb72f329b26403e9fecea6009b4818ed Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Fri, 12 Feb 2021 19:27:25 -0800 Subject: [PATCH 19/43] Fixed prev returned frame --- perception/tasks/segmentation/COMB_SAL_BG.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py index 92fb9ff..9562b40 100644 --- a/perception/tasks/segmentation/COMB_SAL_BG.py +++ b/perception/tasks/segmentation/COMB_SAL_BG.py @@ -15,8 +15,7 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): sal = self.sal.analyze(frame, debug, slider_vals=slider_vals) bg = self.bg.analyze(frame,debug, slider_vals=slider_vals) # print(type(sal), type(bg)) - ret = np.zeros(sal[0].shape) - cv.bitwise_and(sal[0],bg[0], dst=ret) + ret = cv.bitwise_and(sal[0],bg[0]) # small = min(cv.s) # print (type(ret)) - return frame, [frame, sal[0], bg[0], ret] \ No newline at end of file + return frame, [frame, ret] \ No newline at end of file From 99e3b1e676625eda3c5fb27d67b9d494eb2d8e65 Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sun, 14 Feb 2021 17:09:35 -0800 Subject: [PATCH 20/43] Updated combined file --- perception/tasks/segmentation/COMB_SAL_BG.py | 35 +- .../segmentation/saliency_detection/MBD.py | 5 +- .../saliency_detection/saliency_mbd.c | 10817 ++++++---------- perception/vis/vis.py | 2 +- 4 files changed, 3808 insertions(+), 7051 deletions(-) diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py index 9562b40..f53214c 100644 --- a/perception/tasks/segmentation/COMB_SAL_BG.py +++ b/perception/tasks/segmentation/COMB_SAL_BG.py @@ -4,18 +4,41 @@ from typing import Dict from perception.tasks.segmentation.saliency_detection.MBD import MBD from perception.vis.TestTasks.BackgroundRemoval import BackgroundRemoval +from threading import Thread +import queue +import concurrent.futures +from multiprocessing import Pool class COMB_SAL_BG(TaskPerceiver): def __init__(self, **kwargs): super().__init__(blur = ((0, 10), 2), lamda = ((0,10),1), lower_bound=((0,255), 10)) self.sal = MBD() self.bg = BackgroundRemoval() - - def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + # self.q = queue.Queue() + + # def f(frame: np.ndarray, debug: bool, slider_vals: Dict[str, int], use_mbd: bool): + # print('working!') + # if use_mbd: + # print('Im HERE!!!!') + # ret = self.sal.analyze(frame, debug, slider_vals=slider_vals) + # else: + # print('Im NOT :( HERE!!!!') + # ret = self.bg.analyze(frame,debug, slider_vals=slider_vals) + # return ret + + def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): + # sal_thread = Thread(target=self.sal.analyze, args=(frame, debug, slider_vals, self.q)) + # bg_thread = Thread(target=self.bg.analyze, args=(frame, debug, slider_vals, self.q)) + # bg_thread.__setattr__('_args', (frame, debug, slider_vals, self.q)) + # sal_thread.start() + # bg_thread.start() + # sal_thread.join() + # bg_thread.join() + # ret = cv.bitwise_and(self.q.get(),self.q.get()) + sal = self.sal.analyze(frame, debug, slider_vals=slider_vals) bg = self.bg.analyze(frame,debug, slider_vals=slider_vals) - # print(type(sal), type(bg)) ret = cv.bitwise_and(sal[0],bg[0]) - # small = min(cv.s) - # print (type(ret)) - return frame, [frame, ret] \ No newline at end of file + contours = cv.findContours(ret, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE) + cv.drawContours(ret, contours[1], -1, (0,255,0), 3) + return frame, [frame, sal[0], bg[0], ret] \ No newline at end of file diff --git a/perception/tasks/segmentation/saliency_detection/MBD.py b/perception/tasks/segmentation/saliency_detection/MBD.py index c043e5d..beaa562 100644 --- a/perception/tasks/segmentation/saliency_detection/MBD.py +++ b/perception/tasks/segmentation/saliency_detection/MBD.py @@ -11,5 +11,6 @@ def __init__(self, **kwargs): def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): mbd = get_saliency_mbd(frame).astype('uint8') - ret3,th3 = cv.threshold(mbd,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU) - return th3, [frame, mbd, th3] + # ret3,th3 = cv.threshold(mbd,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU) + # q.put(mbd) + return mbd, [frame, mbd] diff --git a/perception/tasks/segmentation/saliency_detection/saliency_mbd.c b/perception/tasks/segmentation/saliency_detection/saliency_mbd.c index bd12c09..bc3627f 100644 --- a/perception/tasks/segmentation/saliency_detection/saliency_mbd.c +++ b/perception/tasks/segmentation/saliency_detection/saliency_mbd.c @@ -1,5 +1,18 @@ /* Generated by Cython 0.29.21 */ +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [], + "name": "saliency_mbd", + "sources": [ + "/Users/karthikdharmarajan/Documents/URobotics/perception/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx" + ] + }, + "module_name": "saliency_mbd" +} +END: Cython Metadata */ + #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H @@ -840,7 +853,7 @@ static const char *__pyx_filename; static const char *__pyx_f[] = { - "saliency_mbd.pyx", + "tasks/segmentation/saliency_detection/saliency_mbd.pyx", "__init__.pxd", "type.pxd", }; @@ -881,7 +894,7 @@ typedef struct { } __Pyx_BufFmt_Context; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":775 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":775 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -890,7 +903,7 @@ typedef struct { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -899,7 +912,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -908,7 +921,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -917,7 +930,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -926,7 +939,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -935,7 +948,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -944,7 +957,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -953,7 +966,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":789 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":789 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -962,7 +975,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -971,7 +984,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -980,7 +993,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -989,7 +1002,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -998,7 +1011,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -1007,7 +1020,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -1016,7 +1029,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -1025,7 +1038,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":807 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":807 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -1034,7 +1047,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -1043,7 +1056,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":810 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":810 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -1052,7 +1065,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -1061,7 +1074,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -1096,7 +1109,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do /*--- Type declarations ---*/ -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -1105,7 +1118,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -1114,7 +1127,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -1123,7 +1136,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -1417,56 +1430,6 @@ static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) #endif -/* PyIntFromDouble.proto */ -#if PY_MAJOR_VERSION < 3 -static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value); -#else -#define __Pyx_PyInt_FromDouble(value) PyLong_FromDouble(value) -#endif - -/* ObjectGetItem.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); -#else -#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) -#endif - -/* PyIntBinop.proto */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); -#else -#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ - (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) -#endif - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); - -/* UnpackItemEndCheck.proto */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); - -/* PyFloatBinop.proto */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); -#else -#define __Pyx_PyFloat_DivideObjC(op1, op2, floatval, inplace, zerodivision_check)\ - ((inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2))) - #endif - -/* PyIntBinop.proto */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); -#else -#define __Pyx_PyInt_SubtractCObj(op1, op2, intval, inplace, zerodivision_check)\ - (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) -#endif - /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); @@ -1499,6 +1462,12 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); @@ -1606,9 +1575,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value); - /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus @@ -1785,56 +1751,34 @@ static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; -static const char __pyx_k_T[] = "T"; static const char __pyx_k_b[] = "b"; static const char __pyx_k_f[] = "f"; static const char __pyx_k_x[] = "x"; -static const char __pyx_k_VI[] = "VI"; static const char __pyx_k_np[] = "np"; -static const char __pyx_k_cov[] = "cov"; static const char __pyx_k_img[] = "img"; -static const char __pyx_k_inv[] = "inv"; -static const char __pyx_k_max[] = "max"; static const char __pyx_k_sys[] = "sys"; static const char __pyx_k_axis[] = "axis"; static const char __pyx_k_copy[] = "copy"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mean[] = "mean"; static const char __pyx_k_name[] = "__name__"; -static const char __pyx_k_sqrt[] = "sqrt"; static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_cdist[] = "cdist"; -static const char __pyx_k_color[] = "color"; static const char __pyx_k_numpy[] = "numpy"; -static const char __pyx_k_power[] = "power"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_scipy[] = "scipy"; -static const char __pyx_k_shape[] = "shape"; -static const char __pyx_k_zeros[] = "zeros"; -static const char __pyx_k_arange[] = "arange"; static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_linalg[] = "linalg"; static const char __pyx_k_method[] = "method"; -static const char __pyx_k_maximum[] = "maximum"; -static const char __pyx_k_reshape[] = "reshape"; -static const char __pyx_k_rgb2lab[] = "rgb2lab"; static const char __pyx_k_skimage[] = "skimage"; -static const char __pyx_k_spatial[] = "spatial"; -static const char __pyx_k_distance[] = "distance"; -static const char __pyx_k_meshgrid[] = "meshgrid"; static const char __pyx_k_minimize[] = "minimize"; static const char __pyx_k_full_like[] = "full_like"; -static const char __pyx_k_vectorize[] = "vectorize"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_skimage_io[] = "skimage.io"; static const char __pyx_k_ImportError[] = "ImportError"; -static const char __pyx_k_mahalanobis[] = "mahalanobis"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_img_as_float[] = "img_as_float"; static const char __pyx_k_saliency_mbd[] = "saliency_mbd"; static const char __pyx_k_skimage_util[] = "skimage.util"; static const char __pyx_k_scipy_optimize[] = "scipy.optimize"; -static const char __pyx_k_saliency_mbd_pyx[] = "saliency_mbd.pyx"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_scipy_spatial_distance[] = "scipy.spatial.distance"; static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; @@ -1844,37 +1788,25 @@ static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string al static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static const char __pyx_k_tasks_segmentation_saliency_dete[] = "tasks/segmentation/saliency_detection/saliency_mbd.pyx"; static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; static PyObject *__pyx_n_s_RuntimeError; -static PyObject *__pyx_n_s_T; -static PyObject *__pyx_n_s_VI; static PyObject *__pyx_n_s_ValueError; -static PyObject *__pyx_n_s_arange; static PyObject *__pyx_n_s_axis; static PyObject *__pyx_n_s_b; -static PyObject *__pyx_n_s_cdist; static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_color; static PyObject *__pyx_n_s_copy; -static PyObject *__pyx_n_s_cov; -static PyObject *__pyx_n_s_distance; static PyObject *__pyx_n_s_f; static PyObject *__pyx_n_s_full_like; static PyObject *__pyx_n_s_img; static PyObject *__pyx_n_s_img_as_float; static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_inv; -static PyObject *__pyx_n_s_linalg; -static PyObject *__pyx_n_s_mahalanobis; static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_max; -static PyObject *__pyx_n_s_maximum; static PyObject *__pyx_n_s_mean; -static PyObject *__pyx_n_s_meshgrid; static PyObject *__pyx_n_s_method; static PyObject *__pyx_n_s_minimize; static PyObject *__pyx_n_s_name; @@ -1884,38 +1816,27 @@ static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; -static PyObject *__pyx_n_s_power; static PyObject *__pyx_n_s_range; -static PyObject *__pyx_n_s_reshape; -static PyObject *__pyx_n_s_rgb2lab; static PyObject *__pyx_n_s_saliency_mbd; -static PyObject *__pyx_kp_s_saliency_mbd_pyx; static PyObject *__pyx_n_s_scipy; static PyObject *__pyx_n_s_scipy_optimize; static PyObject *__pyx_n_s_scipy_spatial_distance; -static PyObject *__pyx_n_s_shape; static PyObject *__pyx_n_s_skimage; static PyObject *__pyx_n_s_skimage_io; static PyObject *__pyx_n_s_skimage_util; -static PyObject *__pyx_n_s_spatial; -static PyObject *__pyx_n_s_sqrt; static PyObject *__pyx_n_s_sys; +static PyObject *__pyx_kp_s_tasks_segmentation_saliency_dete; static PyObject *__pyx_n_s_test; static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; -static PyObject *__pyx_n_s_vectorize; static PyObject *__pyx_n_s_x; -static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method); /* proto */ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_float_0_5; -static PyObject *__pyx_float_2_0; static PyObject *__pyx_float_255_0; static PyObject *__pyx_int_0; -static PyObject *__pyx_int_1; static PyObject *__pyx_int_2; -static PyObject *__pyx_int_3; static PyObject *__pyx_int_10000000; static PyObject *__pyx_int_neg_1; static PyObject *__pyx_slice_; @@ -1931,9 +1852,7 @@ static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; -static PyObject *__pyx_tuple__14; -static PyObject *__pyx_tuple__15; -static PyObject *__pyx_codeobj__16; +static PyObject *__pyx_codeobj__14; /* Late includes */ /* "saliency_mbd.pyx":15 @@ -3372,65 +3291,12 @@ static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_img, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd *__pyx_optional_args) { PyObject *__pyx_v_img_mean = NULL; PyObject *__pyx_v_sal = NULL; - int __pyx_v_n_rows; - int __pyx_v_n_cols; - CYTHON_UNUSED int __pyx_v_n_channels; - double __pyx_v_img_size; - PyObject *__pyx_v_border_thickness = NULL; - PyArrayObject *__pyx_v_img_lab = 0; - PyObject *__pyx_v_px_left = NULL; - PyObject *__pyx_v_px_right = NULL; - PyObject *__pyx_v_px_top = NULL; - PyObject *__pyx_v_px_bottom = NULL; - PyObject *__pyx_v_px_mean_left = NULL; - PyObject *__pyx_v_px_mean_right = NULL; - PyObject *__pyx_v_px_mean_top = NULL; - PyObject *__pyx_v_px_mean_bottom = NULL; - PyObject *__pyx_v_cov_left = NULL; - PyObject *__pyx_v_cov_right = NULL; - PyObject *__pyx_v_cov_top = NULL; - PyObject *__pyx_v_cov_bottom = NULL; - PyObject *__pyx_v_u_left = NULL; - PyObject *__pyx_v_u_right = NULL; - PyObject *__pyx_v_u_top = NULL; - PyObject *__pyx_v_u_bottom = NULL; - PyObject *__pyx_v_u_final = NULL; - PyObject *__pyx_v_img_lab_unrolled = NULL; - PyObject *__pyx_v_px_mean_left_2 = NULL; - PyObject *__pyx_v_px_mean_right_2 = NULL; - PyObject *__pyx_v_px_mean_top_2 = NULL; - PyObject *__pyx_v_px_mean_bottom_2 = NULL; - PyObject *__pyx_v_max_u_left = NULL; - PyObject *__pyx_v_max_u_right = NULL; - PyObject *__pyx_v_max_u_top = NULL; - PyObject *__pyx_v_max_u_bottom = NULL; - PyObject *__pyx_v_u_max = NULL; - PyObject *__pyx_v_u_max_final = NULL; - PyObject *__pyx_v_sal_max = NULL; - PyObject *__pyx_v_s = NULL; - double __pyx_v_alpha; - CYTHON_UNUSED double __pyx_v_delta; - PyObject *__pyx_v_xv = NULL; - PyObject *__pyx_v_yv = NULL; - PyObject *__pyx_v_w = NULL; - PyObject *__pyx_v_h = NULL; - double __pyx_v_w2; - double __pyx_v_h2; - PyObject *__pyx_v_C = NULL; - PyObject *__pyx_v_fv = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - double __pyx_t_10; - PyObject *(*__pyx_t_11)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -3471,7 +3337,7 @@ static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_ * img_mean = np.mean(img,axis=(2)) * sal = mbd(img_mean,2) # <<<<<<<<<<<<<< * - * cdef int n_rows = img.shape[0] + * #cdef int n_rows = img.shape[0] */ if (!(likely(((__pyx_v_img_mean) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_img_mean, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 135, __pyx_L1_error) __pyx_t_4 = __pyx_f_12saliency_mbd_mbd(((PyArrayObject *)__pyx_v_img_mean), 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error) @@ -3479,7404 +3345,4413 @@ static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_ __pyx_v_sal = __pyx_t_4; __pyx_t_4 = 0; - /* "saliency_mbd.pyx":137 - * sal = mbd(img_mean,2) + /* "saliency_mbd.pyx":250 + * #sal = fv(sal) * - * cdef int n_rows = img.shape[0] # <<<<<<<<<<<<<< - * cdef int n_cols = img.shape[1] - * cdef int n_channels = img.shape[2] + * return sal* 255.0 # <<<<<<<<<<<<<< */ - __pyx_v_n_rows = (__pyx_v_img->dimensions[0]); + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; - /* "saliency_mbd.pyx":138 + /* "saliency_mbd.pyx":132 * - * cdef int n_rows = img.shape[0] - * cdef int n_cols = img.shape[1] # <<<<<<<<<<<<<< - * cdef int n_channels = img.shape[2] - * cdef double img_size = sqrt(n_rows * n_cols) + * @cython.boundscheck(False) + * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< + * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + * img_mean = np.mean(img,axis=(2)) */ - __pyx_v_n_cols = (__pyx_v_img->dimensions[1]); - /* "saliency_mbd.pyx":139 - * cdef int n_rows = img.shape[0] - * cdef int n_cols = img.shape[1] - * cdef int n_channels = img.shape[2] # <<<<<<<<<<<<<< - * cdef double img_size = sqrt(n_rows * n_cols) - * border_thickness = int(floor(0.1 * img_size)) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_img_mean); + __Pyx_XDECREF(__pyx_v_sal); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_img = 0; + PyObject *__pyx_v_method = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_saliency_mbd (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_img,&__pyx_n_s_method,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)__pyx_n_s_b); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_img)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 132, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_img = ((PyArrayObject *)values[0]); + __pyx_v_method = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 132, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_r = __pyx_pf_12saliency_mbd_2get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_saliency_mbd", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.method = __pyx_v_method; + __pyx_t_1 = __pyx_f_12saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fulfill the PEP. */ - __pyx_v_n_channels = (__pyx_v_img->dimensions[2]); - /* "saliency_mbd.pyx":140 - * cdef int n_cols = img.shape[1] - * cdef int n_channels = img.shape[2] - * cdef double img_size = sqrt(n_rows * n_cols) # <<<<<<<<<<<<<< - * border_thickness = int(floor(0.1 * img_size)) +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyArray_Descr *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * + * cdef int i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) * */ - __pyx_v_img_size = sqrt((__pyx_v_n_rows * __pyx_v_n_cols)); + __pyx_v_endian_detector = 1; - /* "saliency_mbd.pyx":141 - * cdef int n_channels = img.shape[2] - * cdef double img_size = sqrt(n_rows * n_cols) - * border_thickness = int(floor(0.1 * img_size)) # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * cdef int i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * - * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) + * ndim = PyArray_NDIM(self) */ - __pyx_t_4 = __Pyx_PyInt_FromDouble(floor((0.1 * __pyx_v_img_size))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_v_border_thickness = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "saliency_mbd.pyx":143 - * border_thickness = int(floor(0.1 * img_size)) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * cdef bint little_endian = ((&endian_detector)[0] != 0) * - * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) # <<<<<<<<<<<<<< + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * - * px_left = img_lab[0:border_thickness,:,:] + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_skimage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_color); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_rgb2lab); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_img)); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 143, __pyx_L1_error) - __pyx_v_img_lab = ((PyArrayObject *)__pyx_t_4); - __pyx_t_4 = 0; - - /* "saliency_mbd.pyx":145 - * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) - * - * px_left = img_lab[0:border_thickness,:,:] # <<<<<<<<<<<<<< - * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] - * - */ - __pyx_t_4 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_slice_); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_px_left = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); - /* "saliency_mbd.pyx":146 - * - * px_left = img_lab[0:border_thickness,:,:] - * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) * - * px_top = img_lab[:,0:border_thickness,:] + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_v_border_thickness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PySlice_New(__pyx_t_4, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_slice_); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_px_right = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } - /* "saliency_mbd.pyx":148 - * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 * - * px_top = img_lab[:,0:border_thickness,:] # <<<<<<<<<<<<<< - * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") * */ - __pyx_t_3 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_slice_); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_px_top = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; - /* "saliency_mbd.pyx":149 - * - * px_top = img_lab[:,0:border_thickness,:] - * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) * - * px_mean_left = np.mean(px_left,axis=(0,1)) + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_v_border_thickness); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PySlice_New(__pyx_t_3, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_slice_); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_px_bottom = __pyx_t_4; - __pyx_t_4 = 0; + if (unlikely(__pyx_t_1)) { - /* "saliency_mbd.pyx":151 - * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * - * px_mean_left = np.mean(px_left,axis=(0,1)) # <<<<<<<<<<<<<< - * px_mean_right = np.mean(px_right,axis=(0,1)) - * px_mean_top = np.mean(px_top,axis=(0,1)) + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_px_left); - __Pyx_GIVEREF(__pyx_v_px_left); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_px_left); - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 151, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_px_mean_left = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 272, __pyx_L1_error) - /* "saliency_mbd.pyx":152 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) * - * px_mean_left = np.mean(px_left,axis=(0,1)) - * px_mean_right = np.mean(px_right,axis=(0,1)) # <<<<<<<<<<<<<< - * px_mean_top = np.mean(px_top,axis=(0,1)) - * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_v_px_right); - __Pyx_GIVEREF(__pyx_v_px_right); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_px_right); - __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 152, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_px_mean_right = __pyx_t_3; - __pyx_t_3 = 0; + } - /* "saliency_mbd.pyx":153 - * px_mean_left = np.mean(px_left,axis=(0,1)) - * px_mean_right = np.mean(px_right,axis=(0,1)) - * px_mean_top = np.mean(px_top,axis=(0,1)) # <<<<<<<<<<<<<< - * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_px_top); - __Pyx_GIVEREF(__pyx_v_px_top); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_px_top); - __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 153, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_px_mean_top = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L7_bool_binop_done; + } - /* "saliency_mbd.pyx":154 - * px_mean_right = np.mean(px_right,axis=(0,1)) - * px_mean_top = np.mean(px_top,axis=(0,1)) - * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_px_bottom); - __Pyx_GIVEREF(__pyx_v_px_bottom); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_px_bottom); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 154, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_px_mean_bottom = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L7_bool_binop_done:; - /* "saliency_mbd.pyx":157 - * - * - * px_left = px_left.reshape((n_cols*border_thickness,3)) # <<<<<<<<<<<<<< - * px_right = px_right.reshape((n_cols*border_thickness,3)) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __Pyx_INCREF(__pyx_int_3); - __Pyx_GIVEREF(__pyx_int_3); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); - __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_px_left, __pyx_t_4); - __pyx_t_4 = 0; + if (unlikely(__pyx_t_1)) { - /* "saliency_mbd.pyx":158 - * - * px_left = px_left.reshape((n_cols*border_thickness,3)) - * px_right = px_right.reshape((n_cols*border_thickness,3)) # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * - * px_top = px_top.reshape((n_rows*border_thickness,3)) + * info.buf = PyArray_DATA(self) */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __Pyx_INCREF(__pyx_int_3); - __Pyx_GIVEREF(__pyx_int_3); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); - __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_px_right, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 276, __pyx_L1_error) - /* "saliency_mbd.pyx":160 - * px_right = px_right.reshape((n_cols*border_thickness,3)) - * - * px_top = px_top.reshape((n_rows*border_thickness,3)) # <<<<<<<<<<<<<< - * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __Pyx_INCREF(__pyx_int_3); - __Pyx_GIVEREF(__pyx_int_3); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); - __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_px_top, __pyx_t_4); - __pyx_t_4 = 0; - /* "saliency_mbd.pyx":161 - * - * px_top = px_top.reshape((n_rows*border_thickness,3)) - * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * raise ValueError(u"ndarray is not Fortran contiguous") * - * cov_left = np.cov(px_left.T) + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __Pyx_INCREF(__pyx_int_3); - __Pyx_GIVEREF(__pyx_int_3); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); - __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_px_bottom, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); - /* "saliency_mbd.pyx":163 - * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) - * - * cov_left = np.cov(px_left.T) # <<<<<<<<<<<<<< - * cov_right = np.cov(px_right.T) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * # Allocate new buffer for strides and shape info. */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_cov_left = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_info->ndim = __pyx_v_ndim; - /* "saliency_mbd.pyx":164 - * - * cov_left = np.cov(px_left.T) - * cov_right = np.cov(px_right.T) # <<<<<<<<<<<<<< - * - * cov_top = np.cov(px_top.T) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_cov_right = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { - /* "saliency_mbd.pyx":166 - * cov_right = np.cov(px_right.T) - * - * cov_top = np.cov(px_top.T) # <<<<<<<<<<<<<< - * cov_bottom = np.cov(px_bottom.T) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_cov_top = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); - /* "saliency_mbd.pyx":167 - * - * cov_top = np.cov(px_top.T) - * cov_bottom = np.cov(px_bottom.T) # <<<<<<<<<<<<<< - * - * cov_left = np.linalg.inv(cov_left) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * # This is allocated as one block, strides first. + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_cov_bottom = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); - /* "saliency_mbd.pyx":169 - * cov_bottom = np.cov(px_bottom.T) - * - * cov_left = np.linalg.inv(cov_left) # <<<<<<<<<<<<<< - * cov_right = np.linalg.inv(cov_right) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L9; } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_left) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_left); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_cov_left, __pyx_t_4); - __pyx_t_4 = 0; - /* "saliency_mbd.pyx":170 - * - * cov_left = np.linalg.inv(cov_left) - * cov_right = np.linalg.inv(cov_right) # <<<<<<<<<<<<<< - * - * cov_top = np.linalg.inv(cov_top) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_right) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_right); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_cov_right, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_L9:; - /* "saliency_mbd.pyx":172 - * cov_right = np.linalg.inv(cov_right) - * - * cov_top = np.linalg.inv(cov_top) # <<<<<<<<<<<<<< - * cov_bottom = np.linalg.inv(cov_bottom) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_top) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_top); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_cov_top, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); - /* "saliency_mbd.pyx":173 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< * - * cov_top = np.linalg.inv(cov_top) - * cov_bottom = np.linalg.inv(cov_bottom) # <<<<<<<<<<<<<< + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = PyArray_DESCR(self) + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< + * cdef int offset * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_bottom); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 173, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_cov_bottom, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_t_7 = PyArray_DESCR(__pyx_v_self); + __pyx_t_3 = ((PyObject *)__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; - /* "saliency_mbd.pyx":176 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 + * cdef int offset * + * info.obj = self # <<<<<<<<<<<<<< * - * u_left = np.zeros(sal.shape) # <<<<<<<<<<<<<< - * u_right = np.zeros(sal.shape) - * u_top = np.zeros(sal.shape) + * if not PyDataType_HASFIELDS(descr): */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_u_left = __pyx_t_4; - __pyx_t_4 = 0; + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - /* "saliency_mbd.pyx":177 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 + * info.obj = self * - * u_left = np.zeros(sal.shape) - * u_right = np.zeros(sal.shape) # <<<<<<<<<<<<<< - * u_top = np.zeros(sal.shape) - * u_bottom = np.zeros(sal.shape) - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_u_right = __pyx_t_4; - __pyx_t_4 = 0; - - /* "saliency_mbd.pyx":178 - * u_left = np.zeros(sal.shape) - * u_right = np.zeros(sal.shape) - * u_top = np.zeros(sal.shape) # <<<<<<<<<<<<<< - * u_bottom = np.zeros(sal.shape) - * - */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_u_top = __pyx_t_4; - __pyx_t_4 = 0; - - /* "saliency_mbd.pyx":179 - * u_right = np.zeros(sal.shape) - * u_top = np.zeros(sal.shape) - * u_bottom = np.zeros(sal.shape) # <<<<<<<<<<<<<< - * - * u_final = np.zeros(sal.shape) + * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_u_bottom = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); + if (__pyx_t_1) { - /* "saliency_mbd.pyx":181 - * u_bottom = np.zeros(sal.shape) - * - * u_final = np.zeros(sal.shape) # <<<<<<<<<<<<<< - * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 * + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 181, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_u_final = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; - /* "saliency_mbd.pyx":182 - * - * u_final = np.zeros(sal.shape) - * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) # <<<<<<<<<<<<<< - * - * px_mean_left_2 = np.zeros((1,3)) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_img_lab), __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(((__pyx_v_img_lab->dimensions[0]) * (__pyx_v_img_lab->dimensions[1]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_6 = 1; + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L15_next_or; + } else { } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else - #endif - { - __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (__pyx_t_2) { - __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; } - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_t_3); - __Pyx_INCREF(__pyx_int_3); - __Pyx_GIVEREF(__pyx_int_3); - PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_int_3); - __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_img_lab_unrolled = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_L15_next_or:; - /* "saliency_mbd.pyx":184 - * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) - * - * px_mean_left_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< - * px_mean_left_2[0,:] = px_mean_left - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; } - } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_tuple__7); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_px_mean_left_2 = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L14_bool_binop_done:; - /* "saliency_mbd.pyx":185 - * - * px_mean_left_2 = np.zeros((1,3)) - * px_mean_left_2[0,:] = px_mean_left # <<<<<<<<<<<<<< - * - * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - if (unlikely(PyObject_SetItem(__pyx_v_px_mean_left_2, __pyx_tuple__2, __pyx_v_px_mean_left) < 0)) __PYX_ERR(0, 185, __pyx_L1_error) + if (unlikely(__pyx_t_1)) { - /* "saliency_mbd.pyx":187 - * px_mean_left_2[0,:] = px_mean_left - * - * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) # <<<<<<<<<<<<<< - * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_scipy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_spatial); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_distance); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_cdist); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_img_lab_unrolled); - __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_img_lab_unrolled); - __Pyx_INCREF(__pyx_v_px_mean_left_2); - __Pyx_GIVEREF(__pyx_v_px_mean_left_2); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_px_mean_left_2); - __Pyx_INCREF(__pyx_n_s_mahalanobis); - __Pyx_GIVEREF(__pyx_n_s_mahalanobis); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_n_s_mahalanobis); - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_left) < 0) __PYX_ERR(0, 187, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 306, __pyx_L1_error) - /* "saliency_mbd.pyx":188 - * - * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) - * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< - * - * px_mean_right_2 = np.zeros((1,3)) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_5); - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); } - } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3); - __pyx_t_3 = 0; - /* "saliency_mbd.pyx":190 - * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) - * - * px_mean_right_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< - * px_mean_right_2[0,:] = px_mean_right - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_tuple__7); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_px_mean_right_2 = __pyx_t_3; - __pyx_t_3 = 0; + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = ((char *)"b"); + break; + case NPY_UBYTE: - /* "saliency_mbd.pyx":191 - * - * px_mean_right_2 = np.zeros((1,3)) - * px_mean_right_2[0,:] = px_mean_right # <<<<<<<<<<<<<< - * - * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" */ - if (unlikely(PyObject_SetItem(__pyx_v_px_mean_right_2, __pyx_tuple__2, __pyx_v_px_mean_right) < 0)) __PYX_ERR(0, 191, __pyx_L1_error) + __pyx_v_f = ((char *)"B"); + break; + case NPY_SHORT: - /* "saliency_mbd.pyx":193 - * px_mean_right_2[0,:] = px_mean_right - * - * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) # <<<<<<<<<<<<<< - * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_scipy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_spatial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_distance); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cdist); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_img_lab_unrolled); - __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_img_lab_unrolled); - __Pyx_INCREF(__pyx_v_px_mean_right_2); - __Pyx_GIVEREF(__pyx_v_px_mean_right_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_px_mean_right_2); - __Pyx_INCREF(__pyx_n_s_mahalanobis); - __Pyx_GIVEREF(__pyx_n_s_mahalanobis); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_n_s_mahalanobis); - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_right) < 0) __PYX_ERR(0, 193, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5); - __pyx_t_5 = 0; + __pyx_v_f = ((char *)"h"); + break; + case NPY_USHORT: - /* "saliency_mbd.pyx":194 - * - * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) - * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< - * - * px_mean_top_2 = np.zeros((1,3)) - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 194, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); - __pyx_t_3 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5); - __pyx_t_5 = 0; - - /* "saliency_mbd.pyx":196 - * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) - * - * px_mean_top_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< - * px_mean_top_2[0,:] = px_mean_top - * - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 196, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_tuple__7); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 196, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_px_mean_top_2 = __pyx_t_5; - __pyx_t_5 = 0; - - /* "saliency_mbd.pyx":197 - * - * px_mean_top_2 = np.zeros((1,3)) - * px_mean_top_2[0,:] = px_mean_top # <<<<<<<<<<<<<< - * - * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) - */ - if (unlikely(PyObject_SetItem(__pyx_v_px_mean_top_2, __pyx_tuple__2, __pyx_v_px_mean_top) < 0)) __PYX_ERR(0, 197, __pyx_L1_error) - - /* "saliency_mbd.pyx":199 - * px_mean_top_2[0,:] = px_mean_top - * - * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) # <<<<<<<<<<<<<< - * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_scipy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_spatial); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_distance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_cdist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_v_img_lab_unrolled); - __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_img_lab_unrolled); - __Pyx_INCREF(__pyx_v_px_mean_top_2); - __Pyx_GIVEREF(__pyx_v_px_mean_top_2); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_px_mean_top_2); - __Pyx_INCREF(__pyx_n_s_mahalanobis); - __Pyx_GIVEREF(__pyx_n_s_mahalanobis); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_n_s_mahalanobis); - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_top) < 0) __PYX_ERR(0, 199, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2); - __pyx_t_2 = 0; + __pyx_v_f = ((char *)"H"); + break; + case NPY_INT: - /* "saliency_mbd.pyx":200 - * - * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) - * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< - * - * px_mean_bottom_2 = np.zeros((1,3)) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); - __pyx_t_5 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2); - __pyx_t_2 = 0; + __pyx_v_f = ((char *)"i"); + break; + case NPY_UINT: - /* "saliency_mbd.pyx":202 - * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) - * - * px_mean_bottom_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< - * px_mean_bottom_2[0,:] = px_mean_bottom - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_tuple__7); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_px_mean_bottom_2 = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_v_f = ((char *)"I"); + break; + case NPY_LONG: - /* "saliency_mbd.pyx":203 - * - * px_mean_bottom_2 = np.zeros((1,3)) - * px_mean_bottom_2[0,:] = px_mean_bottom # <<<<<<<<<<<<<< - * - * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" */ - if (unlikely(PyObject_SetItem(__pyx_v_px_mean_bottom_2, __pyx_tuple__2, __pyx_v_px_mean_bottom) < 0)) __PYX_ERR(0, 203, __pyx_L1_error) + __pyx_v_f = ((char *)"l"); + break; + case NPY_ULONG: - /* "saliency_mbd.pyx":205 - * px_mean_bottom_2[0,:] = px_mean_bottom - * - * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) # <<<<<<<<<<<<<< - * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_scipy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_spatial); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_distance); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_cdist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_v_img_lab_unrolled); - __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_img_lab_unrolled); - __Pyx_INCREF(__pyx_v_px_mean_bottom_2); - __Pyx_GIVEREF(__pyx_v_px_mean_bottom_2); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_px_mean_bottom_2); - __Pyx_INCREF(__pyx_n_s_mahalanobis); - __Pyx_GIVEREF(__pyx_n_s_mahalanobis); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_mahalanobis); - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_bottom) < 0) __PYX_ERR(0, 205, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"L"); + break; + case NPY_LONGLONG: - /* "saliency_mbd.pyx":206 - * - * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) - * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< - * - * max_u_left = np.max(u_left) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"q"); + break; + case NPY_ULONGLONG: - /* "saliency_mbd.pyx":208 - * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) - * - * max_u_left = np.max(u_left) # <<<<<<<<<<<<<< - * max_u_right = np.max(u_right) - * max_u_top = np.max(u_top) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_left) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_left); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_max_u_left = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"Q"); + break; + case NPY_FLOAT: - /* "saliency_mbd.pyx":209 - * - * max_u_left = np.max(u_left) - * max_u_right = np.max(u_right) # <<<<<<<<<<<<<< - * max_u_top = np.max(u_top) - * max_u_bottom = np.max(u_bottom) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_right) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_right); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_max_u_right = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"f"); + break; + case NPY_DOUBLE: - /* "saliency_mbd.pyx":210 - * max_u_left = np.max(u_left) - * max_u_right = np.max(u_right) - * max_u_top = np.max(u_top) # <<<<<<<<<<<<<< - * max_u_bottom = np.max(u_bottom) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_top) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_top); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_max_u_top = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"d"); + break; + case NPY_LONGDOUBLE: - /* "saliency_mbd.pyx":211 - * max_u_right = np.max(u_right) - * max_u_top = np.max(u_top) - * max_u_bottom = np.max(u_bottom) # <<<<<<<<<<<<<< - * - * u_left = u_left / max_u_left + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 211, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_bottom); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_max_u_bottom = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"g"); + break; + case NPY_CFLOAT: - /* "saliency_mbd.pyx":213 - * max_u_bottom = np.max(u_bottom) - * - * u_left = u_left / max_u_left # <<<<<<<<<<<<<< - * u_right = u_right / max_u_right - * u_top = u_top / max_u_top + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" */ - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_left, __pyx_v_max_u_left); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 213, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"Zf"); + break; + case NPY_CDOUBLE: - /* "saliency_mbd.pyx":214 - * - * u_left = u_left / max_u_left - * u_right = u_right / max_u_right # <<<<<<<<<<<<<< - * u_top = u_top / max_u_top - * u_bottom = u_bottom / max_u_bottom + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" */ - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_right, __pyx_v_max_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"Zd"); + break; + case NPY_CLONGDOUBLE: - /* "saliency_mbd.pyx":215 - * u_left = u_left / max_u_left - * u_right = u_right / max_u_right - * u_top = u_top / max_u_top # <<<<<<<<<<<<<< - * u_bottom = u_bottom / max_u_bottom - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: */ - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_top, __pyx_v_max_u_top); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"Zg"); + break; + case NPY_OBJECT: - /* "saliency_mbd.pyx":216 - * u_right = u_right / max_u_right - * u_top = u_top / max_u_top - * u_bottom = u_bottom / max_u_bottom # <<<<<<<<<<<<<< - * - * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_bottom, __pyx_v_max_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); - __pyx_t_4 = 0; + __pyx_v_f = ((char *)"O"); + break; + default: - /* "saliency_mbd.pyx":218 - * u_bottom = u_bottom / max_u_bottom - * - * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) # <<<<<<<<<<<<<< - * - * u_final = (u_left + u_right + u_top + u_bottom) - u_max + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_maximum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_maximum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_maximum); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - __pyx_t_6 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_8)) { - PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_3); - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { - PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_3); - } else - #endif - { - __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__pyx_t_7) { - __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; - } - __Pyx_INCREF(__pyx_v_u_left); - __Pyx_GIVEREF(__pyx_v_u_left); - PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_v_u_left); - __Pyx_INCREF(__pyx_v_u_right); - __Pyx_GIVEREF(__pyx_v_u_right); - PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_right); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_6 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else - #endif - { - __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__pyx_t_8) { - __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; - } - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_t_3); - __Pyx_INCREF(__pyx_v_u_top); - __Pyx_GIVEREF(__pyx_v_u_top); - PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_top); - __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 325, __pyx_L1_error) + break; } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - { - __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (__pyx_t_2) { - __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL; - } - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_t_1); - __Pyx_INCREF(__pyx_v_u_bottom); - __Pyx_GIVEREF(__pyx_v_u_bottom); - PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_bottom); - __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_u_max = __pyx_t_4; - __pyx_t_4 = 0; - /* "saliency_mbd.pyx":220 - * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) - * - * u_final = (u_left + u_right + u_top + u_bottom) - u_max # <<<<<<<<<<<<<< - * - * u_max_final = np.max(u_final) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: */ - __pyx_t_4 = PyNumber_Add(__pyx_v_u_left, __pyx_v_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_v_u_top); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_v_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_v_u_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF_SET(__pyx_v_u_final, __pyx_t_5); - __pyx_t_5 = 0; + __pyx_v_info->format = __pyx_v_f; + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; - /* "saliency_mbd.pyx":222 - * u_final = (u_left + u_right + u_top + u_bottom) - u_max + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 + * info.obj = self * - * u_max_final = np.max(u_final) # <<<<<<<<<<<<<< - * sal_max = np.max(sal) - * sal = sal / sal_max + u_final / u_max_final + * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_9, function); - } } - __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_u_final) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_u_final); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_u_max_final = __pyx_t_5; - __pyx_t_5 = 0; - /* "saliency_mbd.pyx":223 - * - * u_max_final = np.max(u_final) - * sal_max = np.max(sal) # <<<<<<<<<<<<<< - * sal = sal / sal_max + u_final / u_max_final + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 + * return + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 + * info.format = PyObject_Malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_9 = __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_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< * + * def __releasebuffer__(ndarray self, Py_buffer* info): */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } + (__pyx_v_f[0]) = '\x00'; } - __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_sal_max = __pyx_t_5; - __pyx_t_5 = 0; - - /* "saliency_mbd.pyx":224 - * u_max_final = np.max(u_final) - * sal_max = np.max(sal) - * sal = sal / sal_max + u_final / u_max_final # <<<<<<<<<<<<<< - * - * #postprocessing - */ - __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_v_sal_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_final, __pyx_v_u_max_final); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_9); - __pyx_t_9 = 0; - /* "saliency_mbd.pyx":229 - * - * # apply centredness map - * sal = sal / np.max(sal) # <<<<<<<<<<<<<< - * - * s = np.mean(sal) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fulfill the PEP. */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } - __pyx_t_9 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_sal); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_5); - __pyx_t_5 = 0; - - /* "saliency_mbd.pyx":231 - * sal = sal / np.max(sal) - * - * s = np.mean(sal) # <<<<<<<<<<<<<< - * cdef double alpha = 50.0 - * cdef double delta = alpha * sqrt(s) - */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 231, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 231, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } - __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 231, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_s = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "saliency_mbd.pyx":232 +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 + * f[0] = c'\0' # Terminate format string * - * s = np.mean(sal) - * cdef double alpha = 50.0 # <<<<<<<<<<<<<< - * cdef double delta = alpha * sqrt(s) + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ - __pyx_v_alpha = 50.0; + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * PyObject_Free(info.strides) + */ + PyObject_Free(__pyx_v_info->format); - /* "saliency_mbd.pyx":233 - * s = np.mean(sal) - * cdef double alpha = 50.0 - * cdef double delta = alpha * sqrt(s) # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * - * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * PyObject_Free(info.strides) + * # info.shape was stored after info.strides in the same block */ - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_s); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 233, __pyx_L1_error) - __pyx_v_delta = (__pyx_v_alpha * sqrt(__pyx_t_10)); + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { - /* "saliency_mbd.pyx":235 - * cdef double delta = alpha * sqrt(s) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * PyObject_Free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block * - * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) # <<<<<<<<<<<<<< - * (w,h) = sal.shape - * cdef double w2 = w/2.0 */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_meshgrid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_arange); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } + PyObject_Free(__pyx_v_info->strides); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * PyObject_Free(info.strides) + * # info.shape was stored after info.strides in the same block + */ } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_8); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_9, function); - __pyx_t_6 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_9)) { - PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { - PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else - #endif - { - __pyx_t_8 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (__pyx_t_1) { - __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); __pyx_t_1 = NULL; - } - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_6, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_6, __pyx_t_2); - __pyx_t_4 = 0; - __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { - PyObject* sequence = __pyx_t_5; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 235, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_9 = PyList_GET_ITEM(sequence, 0); - __pyx_t_8 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(__pyx_t_8); - #else - __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext; - index = 0; __pyx_t_9 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L3_unpacking_failed; - __Pyx_GOTREF(__pyx_t_9); - index = 1; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L3_unpacking_failed; - __Pyx_GOTREF(__pyx_t_8); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 235, __pyx_L1_error) - __pyx_t_11 = NULL; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - goto __pyx_L4_unpacking_done; - __pyx_L3_unpacking_failed:; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_11 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 235, __pyx_L1_error) - __pyx_L4_unpacking_done:; - } - __pyx_v_xv = __pyx_t_9; - __pyx_t_9 = 0; - __pyx_v_yv = __pyx_t_8; - __pyx_t_8 = 0; - - /* "saliency_mbd.pyx":236 - * - * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) - * (w,h) = sal.shape # <<<<<<<<<<<<<< - * cdef double w2 = w/2.0 - * cdef double h2 = h/2.0 - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { - PyObject* sequence = __pyx_t_5; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 236, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_8 = PyList_GET_ITEM(sequence, 0); - __pyx_t_9 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(__pyx_t_9); - #else - __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - #endif - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext; - index = 0; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_8); - index = 1; __pyx_t_9 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_9); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 236, __pyx_L1_error) - __pyx_t_11 = NULL; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - goto __pyx_L6_unpacking_done; - __pyx_L5_unpacking_failed:; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_11 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 236, __pyx_L1_error) - __pyx_L6_unpacking_done:; - } - __pyx_v_w = __pyx_t_8; - __pyx_t_8 = 0; - __pyx_v_h = __pyx_t_9; - __pyx_t_9 = 0; - - /* "saliency_mbd.pyx":237 - * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) - * (w,h) = sal.shape - * cdef double w2 = w/2.0 # <<<<<<<<<<<<<< - * cdef double h2 = h/2.0 - * - */ - __pyx_t_5 = __Pyx_PyFloat_DivideObjC(__pyx_v_w, __pyx_float_2_0, 2.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_w2 = __pyx_t_10; - - /* "saliency_mbd.pyx":238 - * (w,h) = sal.shape - * cdef double w2 = w/2.0 - * cdef double h2 = h/2.0 # <<<<<<<<<<<<<< - * - * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) - */ - __pyx_t_5 = __Pyx_PyFloat_DivideObjC(__pyx_v_h, __pyx_float_2_0, 2.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_h2 = __pyx_t_10; - - /* "saliency_mbd.pyx":240 - * cdef double h2 = h/2.0 - * - * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) # <<<<<<<<<<<<<< - * - * sal = sal * C - */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyNumber_Subtract(__pyx_v_xv, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2}; - __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2}; - __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - { - __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (__pyx_t_2) { - __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL; - } - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_t_1); - __Pyx_INCREF(__pyx_int_2); - __Pyx_GIVEREF(__pyx_int_2); - PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_int_2); - __pyx_t_1 = 0; - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = PyNumber_Subtract(__pyx_v_yv, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_6 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else - #endif - { - __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (__pyx_t_3) { - __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; - } - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_2); - __Pyx_INCREF(__pyx_int_2); - __Pyx_GIVEREF(__pyx_int_2); - PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2); - __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyNumber_Add(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_6 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_1, __pyx_int_2}; - __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_1, __pyx_int_2}; - __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - { - __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (__pyx_t_9) { - __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL; - } - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_1); - __Pyx_INCREF(__pyx_int_2); - __Pyx_GIVEREF(__pyx_int_2); - PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2); - __pyx_t_1 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = NULL; - __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_9); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_6 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_int_2}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_int_2}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } else - #endif - { - __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__pyx_t_9) { - __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_9); __pyx_t_9 = NULL; - } - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_t_7); - __Pyx_INCREF(__pyx_int_2); - __Pyx_GIVEREF(__pyx_int_2); - PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_int_2); - __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyFloat_FromDouble(sqrt(__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyInt_SubtractCObj(__pyx_int_1, __pyx_t_4, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_C = __pyx_t_1; - __pyx_t_1 = 0; - /* "saliency_mbd.pyx":242 - * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) - * - * sal = sal * C # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 + * f[0] = c'\0' # Terminate format string * - * fv = np.vectorize(f) + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) */ - __pyx_t_1 = PyNumber_Multiply(__pyx_v_sal, __pyx_v_C); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_1); - __pyx_t_1 = 0; - /* "saliency_mbd.pyx":244 - * sal = sal * C - * - * fv = np.vectorize(f) # <<<<<<<<<<<<<< - * - * sal = sal / np.max(sal) - */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_vectorize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_8, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_fv = __pyx_t_1; - __pyx_t_1 = 0; + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} - /* "saliency_mbd.pyx":246 - * fv = np.vectorize(f) +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * ctypedef npy_cdouble complex_t * - * sal = sal / np.max(sal) # <<<<<<<<<<<<<< + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * - * sal = fv(sal) */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4); - __pyx_t_4 = 0; - /* "saliency_mbd.pyx":248 - * sal = sal / np.max(sal) - * - * sal = fv(sal) # <<<<<<<<<<<<<< - * - * return sal* 255.0 - */ - __Pyx_INCREF(__pyx_v_fv); - __pyx_t_1 = __pyx_v_fv; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_sal); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4); - __pyx_t_4 = 0; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* "saliency_mbd.pyx":250 - * sal = fv(sal) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * - * return sal* 255.0 # <<<<<<<<<<<<<< + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "saliency_mbd.pyx":132 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * - * @cython.boundscheck(False) - * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< - * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS - * img_mean = np.mean(img,axis=(2)) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_img_mean); - __Pyx_XDECREF(__pyx_v_sal); - __Pyx_XDECREF(__pyx_v_border_thickness); - __Pyx_XDECREF((PyObject *)__pyx_v_img_lab); - __Pyx_XDECREF(__pyx_v_px_left); - __Pyx_XDECREF(__pyx_v_px_right); - __Pyx_XDECREF(__pyx_v_px_top); - __Pyx_XDECREF(__pyx_v_px_bottom); - __Pyx_XDECREF(__pyx_v_px_mean_left); - __Pyx_XDECREF(__pyx_v_px_mean_right); - __Pyx_XDECREF(__pyx_v_px_mean_top); - __Pyx_XDECREF(__pyx_v_px_mean_bottom); - __Pyx_XDECREF(__pyx_v_cov_left); - __Pyx_XDECREF(__pyx_v_cov_right); - __Pyx_XDECREF(__pyx_v_cov_top); - __Pyx_XDECREF(__pyx_v_cov_bottom); - __Pyx_XDECREF(__pyx_v_u_left); - __Pyx_XDECREF(__pyx_v_u_right); - __Pyx_XDECREF(__pyx_v_u_top); - __Pyx_XDECREF(__pyx_v_u_bottom); - __Pyx_XDECREF(__pyx_v_u_final); - __Pyx_XDECREF(__pyx_v_img_lab_unrolled); - __Pyx_XDECREF(__pyx_v_px_mean_left_2); - __Pyx_XDECREF(__pyx_v_px_mean_right_2); - __Pyx_XDECREF(__pyx_v_px_mean_top_2); - __Pyx_XDECREF(__pyx_v_px_mean_bottom_2); - __Pyx_XDECREF(__pyx_v_max_u_left); - __Pyx_XDECREF(__pyx_v_max_u_right); - __Pyx_XDECREF(__pyx_v_max_u_top); - __Pyx_XDECREF(__pyx_v_max_u_bottom); - __Pyx_XDECREF(__pyx_v_u_max); - __Pyx_XDECREF(__pyx_v_u_max_final); - __Pyx_XDECREF(__pyx_v_sal_max); - __Pyx_XDECREF(__pyx_v_s); - __Pyx_XDECREF(__pyx_v_xv); - __Pyx_XDECREF(__pyx_v_yv); - __Pyx_XDECREF(__pyx_v_w); - __Pyx_XDECREF(__pyx_v_h); - __Pyx_XDECREF(__pyx_v_C); - __Pyx_XDECREF(__pyx_v_fv); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* Python wrapper */ -static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyArrayObject *__pyx_v_img = 0; - PyObject *__pyx_v_method = 0; +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("get_saliency_mbd (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_img,&__pyx_n_s_method,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)__pyx_n_s_b); - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_img)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method); - if (value) { values[1] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 132, __pyx_L3_error) - } - } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_img = ((PyArrayObject *)values[0]); - __pyx_v_method = values[1]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 132, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 132, __pyx_L1_error) - __pyx_r = __pyx_pf_12saliency_mbd_2get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method); + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* function exit code */ + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 824, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ __pyx_L1_error:; - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method) { +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_saliency_mbd", 0); + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2.__pyx_n = 1; - __pyx_t_2.method = __pyx_v_method; - __pyx_t_1 = __pyx_f_12saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 827, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 - * # experimental exception made for __getbuffer__ and __releasebuffer__ - * # -- the details of this may change. - * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< - * # This implementation of getbuffer is geared towards Cython - * # requirements, and does not yet fulfill the PEP. +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * */ -/* Python wrapper */ -static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_v_i; - int __pyx_v_ndim; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - int __pyx_v_t; - char *__pyx_v_f; - PyArray_Descr *__pyx_v_descr = 0; - int __pyx_v_offset; - int __pyx_r; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - PyArray_Descr *__pyx_t_7; - PyObject *__pyx_t_8 = NULL; - char *__pyx_t_9; + PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - if (__pyx_v_info == NULL) { - PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); - return -1; - } - __Pyx_RefNannySetupContext("__getbuffer__", 0); - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * - * cdef int i, ndim - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ - __pyx_v_endian_detector = 1; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 - * cdef int i, ndim - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) * - * ndim = PyArray_NDIM(self) */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 - * cdef bint little_endian = ((&endian_detector)[0] != 0) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * return PyArray_MultiIterNew(4, a, b, c, d) * - * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ - __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") - */ - __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< - * raise ValueError(u"ndarray is not C contiguous") + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * + * cdef inline tuple PyDataType_SHAPE(dtype d): */ - __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 833, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * return PyArray_MultiIterNew(4, a, b, c, d) * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") - */ - if (unlikely(__pyx_t_1)) { - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 272, __pyx_L1_error) - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") - */ - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ - __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L7_bool_binop_done; - } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 - * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< - * raise ValueError(u"ndarray is not Fortran contiguous") - * - */ - __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L7_bool_binop_done:; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< - * - * info.buf = PyArray_DATA(self) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 - * raise ValueError(u"ndarray is not Fortran contiguous") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< * - * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ - __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * info.buf = PyArray_DATA(self) - * info.ndim = ndim # <<<<<<<<<<<<<< - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * # Allocate new buffer for strides and shape info. - */ - __pyx_v_info->ndim = __pyx_v_ndim; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 - * info.buf = PyArray_DATA(self) - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ - __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); - if (__pyx_t_1) { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< - * info.shape = info.strides + ndim - * for i in range(ndim): - */ - __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 - * # This is allocated as one block, strides first. - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) - * info.shape = info.strides + ndim # <<<<<<<<<<<<<< - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * return () + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. */ - __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) - * info.shape = info.strides + ndim - * for i in range(ndim): # <<<<<<<<<<<<<< - * info.strides[i] = PyArray_STRIDES(self)[i] - * info.shape[i] = PyArray_DIMS(self)[i] - */ - __pyx_t_4 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_4; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 - * info.shape = info.strides + ndim - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< - * info.shape[i] = PyArray_DIMS(self)[i] - * else: + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":846 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields */ - (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + __pyx_v_endian_detector = 1; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] - * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< - * else: - * info.strides = PyArray_STRIDES(self) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * */ - (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); - } + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 - * info.buf = PyArray_DATA(self) - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields */ - goto __pyx_L9; + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 850, __pyx_L1_error) } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 850, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 850, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 - * info.shape[i] = PyArray_DIMS(self)[i] - * else: - * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * */ - /*else*/ { - __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 851, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 851, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 - * else: - * info.strides = PyArray_STRIDES(self) - * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: */ - __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); - } - __pyx_L9:; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 - * info.strides = PyArray_STRIDES(self) - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = PyArray_ITEMSIZE(self) - * info.readonly = not PyArray_ISWRITEABLE(self) - */ - __pyx_v_info->suboffsets = NULL; + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 852, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 852, __pyx_L1_error) + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 852, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< - * info.readonly = not PyArray_ISWRITEABLE(self) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854 + * child, new_offset = fields * - */ - __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) - * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * - * cdef int t */ - __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 854, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 854, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 854, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (unlikely(__pyx_t_6)) { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * - * cdef int t - * cdef char* f = NULL # <<<<<<<<<<<<<< - * cdef dtype descr = PyArray_DESCR(self) - * cdef int offset - */ - __pyx_v_f = NULL; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 - * cdef int t - * cdef char* f = NULL - * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< - * cdef int offset + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * + * if ((child.byteorder == c'>' and little_endian) or */ - __pyx_t_7 = PyArray_DESCR(__pyx_v_self); - __pyx_t_3 = ((PyObject *)__pyx_t_7); - __Pyx_INCREF(__pyx_t_3); - __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 855, __pyx_L1_error) - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 - * cdef int offset - * - * info.obj = self # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854 + * child, new_offset = fields * - * if not PyDataType_HASFIELDS(descr): - */ - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 - * info.obj = self + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * - * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or */ - __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); - if (__pyx_t_1) { + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num # <<<<<<<<<<<<<< - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - */ - __pyx_t_4 = __pyx_v_descr->type_num; - __pyx_v_t = __pyx_t_4; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); - if (!__pyx_t_2) { - goto __pyx_L15_next_or; + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; } else { } - __pyx_t_2 = (__pyx_v_little_endian != 0); - if (!__pyx_t_2) { + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L14_bool_binop_done; + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; } - __pyx_L15_next_or:; + __pyx_L8_next_or:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython */ - __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); - if (__pyx_t_2) { + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L14_bool_binop_done; + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; } - __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L14_bool_binop_done:; + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_6)) { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 306, __pyx_L1_error) + __PYX_ERR(1, 859, __pyx_L1_error) - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":869 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 */ - switch (__pyx_v_t) { - case NPY_BYTE: - __pyx_v_f = ((char *)"b"); - break; - case NPY_UBYTE: + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 869, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 869, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 */ - __pyx_v_f = ((char *)"B"); - break; - case NPY_SHORT: + (__pyx_v_f[0]) = 0x78; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * */ - __pyx_v_f = ((char *)"h"); - break; - case NPY_USHORT: + __pyx_v_f = (__pyx_v_f + 1); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize */ - __pyx_v_f = ((char *)"H"); - break; - case NPY_INT: - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" - */ - __pyx_v_f = ((char *)"i"); - break; - case NPY_UINT: - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" - */ - __pyx_v_f = ((char *)"I"); - break; - case NPY_LONG: + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":874 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): */ - __pyx_v_f = ((char *)"l"); - break; - case NPY_ULONG: + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: */ - __pyx_v_f = ((char *)"L"); - break; - case NPY_LONGLONG: + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") */ - __pyx_v_f = ((char *)"q"); - break; - case NPY_ULONGLONG: + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 877, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * */ - __pyx_v_f = ((char *)"Q"); - break; - case NPY_FLOAT: + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (unlikely(__pyx_t_6)) { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_v_f = ((char *)"f"); - break; - case NPY_DOUBLE: + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 879, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 879, __pyx_L1_error) - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * */ - __pyx_v_f = ((char *)"d"); - break; - case NPY_LONGDOUBLE: + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":882 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" */ - __pyx_v_f = ((char *)"g"); - break; - case NPY_CFLOAT: + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 882, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 882, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" */ - __pyx_v_f = ((char *)"Zf"); - break; - case NPY_CDOUBLE: + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" */ - __pyx_v_f = ((char *)"Zd"); - break; - case NPY_CLONGDOUBLE: + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f = "O" - * else: + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" */ - __pyx_v_f = ((char *)"Zg"); - break; - case NPY_OBJECT: + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" */ - __pyx_v_f = ((char *)"O"); - break; - default: + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 - * elif t == NPY_OBJECT: f = "O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * info.format = f - * return + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __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, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 325, __pyx_L1_error) - break; - } - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * info.format = f # <<<<<<<<<<<<<< - * return - * else: - */ - __pyx_v_info->format = __pyx_v_f; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * info.format = f - * return # <<<<<<<<<<<<<< - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ - __pyx_r = 0; - goto __pyx_L0; + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 - * info.obj = self - * - * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ - } + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 - * return - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" */ - /*else*/ { - __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) - * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< - * offset = 0 - * f = _util_dtypestring(descr, info.format + 1, + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ - (__pyx_v_info->format[0]) = '^'; + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 - * info.format = PyObject_Malloc(_buffer_format_string_len) - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 # <<<<<<<<<<<<<< - * f = _util_dtypestring(descr, info.format + 1, - * info.format + _buffer_format_string_len, + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ - __pyx_v_offset = 0; + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 - * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< - * info.format + _buffer_format_string_len, - * &offset) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ - __pyx_t_9 = __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_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) - __pyx_v_f = __pyx_t_9; + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 - * info.format + _buffer_format_string_len, - * &offset) - * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< - * - * def __releasebuffer__(ndarray self, Py_buffer* info): + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ - (__pyx_v_f[0]) = '\x00'; - } + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 - * # experimental exception made for __getbuffer__ and __releasebuffer__ - * # -- the details of this may change. - * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< - * # This implementation of getbuffer is geared towards Cython - * # requirements, and does not yet fulfill the PEP. + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - goto __pyx_L2; - __pyx_L0:; - if (__pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - __pyx_L2:; - __Pyx_XDECREF((PyObject *)__pyx_v_descr); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 - * f[0] = c'\0' # Terminate format string - * - * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } -/* Python wrapper */ -static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ -static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); - __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__releasebuffer__", 0); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 - * - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - */ - __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); - if (__pyx_t_1) { - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) # <<<<<<<<<<<<<< - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * PyObject_Free(info.strides) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ - PyObject_Free(__pyx_v_info->format); + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(__pyx_t_6)) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 - * - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":900 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: */ - } + /*else*/ { + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 900, __pyx_L1_error) + } + __pyx_L15:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * PyObject_Free(info.strides) - * # info.shape was stored after info.strides in the same block + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), */ - __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); - if (__pyx_t_1) { + __pyx_v_f = (__pyx_v_f + 1); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * PyObject_Free(info.strides) # <<<<<<<<<<<<<< - * # info.shape was stored after info.strides in the same block + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876 + * offset[0] += child.itemsize * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: */ - PyObject_Free(__pyx_v_info->strides); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * PyObject_Free(info.strides) - * # info.shape was stored after info.strides in the same block - */ - } + goto __pyx_L13; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 - * f[0] = c'\0' # Terminate format string + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":905 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f * - * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 905, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * cdef tuple fields * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew1(a): - * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew2(a, b): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 821, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_r = __pyx_v_f; goto __pyx_L0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * return () * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021 + * int _import_umath() except -1 * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { - PyObject *__pyx_r = NULL; +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + __Pyx_RefNannySetupContext("set_array_base", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * - * cdef inline object PyArray_MultiIterNew2(a, b): - * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) * - * cdef inline object PyArray_MultiIterNew3(a, b, c): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 824, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + Py_INCREF(__pyx_v_base); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 - * return PyArray_MultiIterNew(1, a) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021 + * int _import_umath() except -1 * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); - return __pyx_r; } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025 + * PyArray_SetBaseObject(arr, base) * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 827, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_v_base = PyArray_BASE(__pyx_v_arr); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base * */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): - * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 830, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025 + * PyArray_SetBaseObject(arr, base) * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * _import_array() */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { - PyObject *__pyx_r = NULL; +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + __Pyx_RefNannySetupContext("import_array", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< - * - * cdef inline tuple PyDataType_SHAPE(dtype d): + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 833, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + * cdef inline int import_array() except -1: + * try: + * _import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1035, __pyx_L3_error) - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 + * try: + * _import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: - */ - __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); - if (__pyx_t_1) { - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape # <<<<<<<<<<<<<< - * else: - * return () */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); - __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); - goto __pyx_L0; + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1036, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 + * _import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: + * cdef inline int import_umath() except -1: */ - } + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1037, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1037, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 - * return d.subarray.shape - * else: - * return () # <<<<<<<<<<<<<< - * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_r = __pyx_empty_tuple; - goto __pyx_L0; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * _import_array() */ /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 - * return () +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039 + * raise ImportError("numpy.core.multiarray failed to import") * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ -static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { - PyArray_Descr *__pyx_v_child = 0; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - PyObject *__pyx_v_fields = 0; - PyObject *__pyx_v_childname = NULL; - PyObject *__pyx_v_new_offset = NULL; - PyObject *__pyx_v_t = NULL; - char *__pyx_r; +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_t_7; - long __pyx_t_8; - char *__pyx_t_9; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_util_dtypestring", 0); + __Pyx_RefNannySetupContext("import_umath", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":846 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * - * cdef dtype child - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * cdef tuple fields + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_v_endian_detector = 1; + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 - * cdef dtype child - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< - * cdef tuple fields - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1041, __pyx_L3_error) - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 - * cdef tuple fields + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - if (unlikely(__pyx_v_descr->names == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 850, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 850, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 850, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); - __pyx_t_3 = 0; + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 - * - * for childname in descr.names: - * fields = descr.fields[childname] # <<<<<<<<<<<<<< - * child, new_offset = fields + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") * */ - if (unlikely(__pyx_v_descr->fields == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 851, __pyx_L1_error) - } - __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 851, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1042, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 - * for childname in descr.names: - * fields = descr.fields[childname] - * child, new_offset = fields # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * - * if (end - f) - (new_offset - offset[0]) < 15: + * cdef inline int import_ufunc() except -1: */ - if (likely(__pyx_v_fields != Py_None)) { - PyObject* sequence = __pyx_v_fields; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 852, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 852, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 852, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1043, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1043, __pyx_L5_except_error) } - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 852, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); - __pyx_t_3 = 0; - __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); - __pyx_t_4 = 0; + goto __pyx_L5_except_error; + __pyx_L5_except_error:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 854, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 854, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 854, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); - if (unlikely(__pyx_t_6)) { + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039 + * raise ImportError("numpy.core.multiarray failed to import") * - * if ((child.byteorder == c'>' and little_endian) or + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 855, __pyx_L1_error) - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - */ - } + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") +/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 + * raise ImportError("numpy.core.umath failed to import") * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); - if (!__pyx_t_7) { - goto __pyx_L8_next_or; - } else { - } - __pyx_t_7 = (__pyx_v_little_endian != 0); - if (!__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_L8_next_or:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 - * - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * # One could encode it in the format string and have Cython - */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); - if (__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_6 = __pyx_t_7; - __pyx_L7_bool_binop_done:; +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - if (unlikely(__pyx_t_6)) { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * # One could encode it in the format string and have Cython - * # complain instead, BUT: < and > in format strings also imply + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 859, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 859, __pyx_L1_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1047, __pyx_L3_error) - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":869 - * - * # Output padding bytes - * while offset[0] < new_offset: # <<<<<<<<<<<<<< - * f[0] = 120 # "x"; pad byte - * f += 1 - */ - while (1) { - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 869, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 869, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 869, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (!__pyx_t_6) break; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 - * # Output padding bytes - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< - * f += 1 - * offset[0] += 1 - */ - (__pyx_v_f[0]) = 0x78; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte - * f += 1 # <<<<<<<<<<<<<< - * offset[0] += 1 - * + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") */ - __pyx_v_f = (__pyx_v_f + 1); + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1048, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 - * f[0] = 120 # "x"; pad byte - * f += 1 - * offset[0] += 1 # <<<<<<<<<<<<<< - * - * offset[0] += child.itemsize + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1049, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1049, __pyx_L5_except_error) } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":874 - * offset[0] += 1 - * - * offset[0] += child.itemsize # <<<<<<<<<<<<<< - * - * if not PyDataType_HASFIELDS(child): - */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876 - * offset[0] += child.itemsize - * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: - */ - __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); - if (__pyx_t_6) { - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * - * if not PyDataType_HASFIELDS(child): - * t = child.type_num # <<<<<<<<<<<<<< - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 877, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); - __pyx_t_4 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 + * raise ImportError("numpy.core.umath failed to import") * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ - __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); - if (unlikely(__pyx_t_6)) { - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< - * - * # Until ticket #99 is fixed, use integers to avoid warnings - */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 879, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 879, __pyx_L1_error) + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") - * - */ - } +static PyMethodDef __pyx_methods[] = { + {"get_saliency_mbd", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_12saliency_mbd_3get_saliency_mbd, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":882 - * - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 882, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 882, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 882, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 98; - goto __pyx_L15; - } +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_saliency_mbd(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_saliency_mbd}, + {0, NULL} +}; +#endif - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 66; - goto __pyx_L15; - } +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "saliency_mbd", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x68; - goto __pyx_L15; - } +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1}, + {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1}, + {&__pyx_n_s_full_like, __pyx_k_full_like, sizeof(__pyx_k_full_like), 0, 0, 1, 1}, + {&__pyx_n_s_img, __pyx_k_img, sizeof(__pyx_k_img), 0, 0, 1, 1}, + {&__pyx_n_s_img_as_float, __pyx_k_img_as_float, sizeof(__pyx_k_img_as_float), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_mean, __pyx_k_mean, sizeof(__pyx_k_mean), 0, 0, 1, 1}, + {&__pyx_n_s_method, __pyx_k_method, sizeof(__pyx_k_method), 0, 0, 1, 1}, + {&__pyx_n_s_minimize, __pyx_k_minimize, sizeof(__pyx_k_minimize), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, + {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_saliency_mbd, __pyx_k_saliency_mbd, sizeof(__pyx_k_saliency_mbd), 0, 0, 1, 1}, + {&__pyx_n_s_scipy, __pyx_k_scipy, sizeof(__pyx_k_scipy), 0, 0, 1, 1}, + {&__pyx_n_s_scipy_optimize, __pyx_k_scipy_optimize, sizeof(__pyx_k_scipy_optimize), 0, 0, 1, 1}, + {&__pyx_n_s_scipy_spatial_distance, __pyx_k_scipy_spatial_distance, sizeof(__pyx_k_scipy_spatial_distance), 0, 0, 1, 1}, + {&__pyx_n_s_skimage, __pyx_k_skimage, sizeof(__pyx_k_skimage), 0, 0, 1, 1}, + {&__pyx_n_s_skimage_io, __pyx_k_skimage_io, sizeof(__pyx_k_skimage_io), 0, 0, 1, 1}, + {&__pyx_n_s_skimage_util, __pyx_k_skimage_util, sizeof(__pyx_k_skimage_util), 0, 0, 1, 1}, + {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, + {&__pyx_kp_s_tasks_segmentation_saliency_dete, __pyx_k_tasks_segmentation_saliency_dete, sizeof(__pyx_k_tasks_segmentation_saliency_dete), 0, 0, 1, 0}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 855, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1037, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "saliency_mbd.pyx":113 + * U = np.copy(img) + * D = np.full_like(img, 10000000) + * D[0,:] = 0 # <<<<<<<<<<<<<< + * D[-1,:] = 0 + * D[:,0] = 0 */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 72; - goto __pyx_L15; - } + __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + __pyx_tuple__2 = PyTuple_Pack(2, __pyx_int_0, __pyx_slice_); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" + /* "saliency_mbd.pyx":114 + * D = np.full_like(img, 10000000) + * D[0,:] = 0 + * D[-1,:] = 0 # <<<<<<<<<<<<<< + * D[:,0] = 0 + * D[:,-1] = 0 */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x69; - goto __pyx_L15; - } + __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_neg_1, __pyx_slice_); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" + /* "saliency_mbd.pyx":115 + * D[0,:] = 0 + * D[-1,:] = 0 + * D[:,0] = 0 # <<<<<<<<<<<<<< + * D[:,-1] = 0 + * */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 73; - goto __pyx_L15; - } + __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" + /* "saliency_mbd.pyx":116 + * D[-1,:] = 0 + * D[:,0] = 0 + * D[:,-1] = 0 # <<<<<<<<<<<<<< + * + * cdef int x */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x6C; - goto __pyx_L15; - } + __pyx_tuple__5 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 76; - goto __pyx_L15; - } + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x71; - goto __pyx_L15; - } + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 81; - goto __pyx_L15; - } + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x66; - goto __pyx_L15; - } + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x64; - goto __pyx_L15; - } - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x67; - goto __pyx_L15; - } - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x66; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x64; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x67; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (likely(__pyx_t_6)) { - (__pyx_v_f[0]) = 79; - goto __pyx_L15; - } - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":900 - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * f += 1 - * else: - */ - /*else*/ { - __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 900, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 900, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 900, __pyx_L1_error) - } - __pyx_L15:; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * f += 1 # <<<<<<<<<<<<<< - * else: - * # Cython ignores struct boundary information ("T{...}"), - */ - __pyx_v_f = (__pyx_v_f + 1); + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 879, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876 - * offset[0] += child.itemsize + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 + * _import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: + * cdef inline int import_umath() except -1: */ - goto __pyx_L13; - } + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 1037, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":905 - * # Cython ignores struct boundary information ("T{...}"), - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< - * return f + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * + * cdef inline int import_ufunc() except -1: */ - /*else*/ { - __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 905, __pyx_L1_error) - __pyx_v_f = __pyx_t_9; - } - __pyx_L13:; + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 1043, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 - * cdef tuple fields + /* "saliency_mbd.pyx":127 + * return D * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields + * def f(x): # <<<<<<<<<<<<<< + * b = 10.0 + * return 1.0 / (1.0 + exp(-b*(x - 0.5))) */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_tuple__13 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_b); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tasks_segmentation_saliency_dete, __pyx_n_s_f, 127, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) - * return f # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_f; - goto __pyx_L0; +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_float_0_5 = PyFloat_FromDouble(0.5); if (unlikely(!__pyx_float_0_5)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_255_0 = PyFloat_FromDouble(255.0); if (unlikely(!__pyx_float_255_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_10000000 = PyInt_FromLong(10000000L); if (unlikely(!__pyx_int_10000000)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 - * return () - * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. - */ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_child); - __Pyx_XDECREF(__pyx_v_fields); - __Pyx_XDECREF(__pyx_v_childname); - __Pyx_XDECREF(__pyx_v_new_offset); - __Pyx_XDECREF(__pyx_v_t); +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); - return __pyx_r; + return 0; } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - -static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { +static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("set_array_base", 0); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 - * - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< - * PyArray_SetBaseObject(arr, base) - * - */ - Py_INCREF(__pyx_v_base); +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< - * - * cdef inline object get_array_base(ndarray arr): - */ - (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - - /* function exit code */ +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); + return 0; } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { - PyObject *__pyx_v_base; - PyObject *__pyx_r = NULL; +static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("get_array_base", 0); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 - * - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< - * if base is NULL: - * return None - */ - __pyx_v_base = PyArray_BASE(__pyx_v_arr); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 917, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base - */ - __pyx_t_1 = ((__pyx_v_base == NULL) != 0); - if (__pyx_t_1) { +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 - * base = PyArray_BASE(arr) - * if base is NULL: - * return None # <<<<<<<<<<<<<< - * return base - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base - */ - } - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 - * if base is NULL: - * return None - * return base # <<<<<<<<<<<<<< - * - * # Versions of the import_* functions which are more suitable for - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_base)); - __pyx_r = ((PyObject *)__pyx_v_base); - goto __pyx_L0; +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initsaliency_mbd(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initsaliency_mbd(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * _import_array() - */ -static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations +static CYTHON_SMALL_CODE int __pyx_pymod_exec_saliency_mbd(PyObject *__pyx_pyinit_module) +#endif +#endif +{ PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; + int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_array", 0); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'saliency_mbd' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("saliency_mbd", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_saliency_mbd) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "saliency_mbd")) { + if (unlikely(PyDict_SetItemString(modules, "saliency_mbd", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 - * cdef inline int import_array() except -1: - * try: - * _import_array() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") + /* "saliency_mbd.pyx":1 + * import sys # <<<<<<<<<<<<<< + * import numpy as np + * cimport numpy as np */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1035, __pyx_L3_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: + /* "saliency_mbd.pyx":2 + * import sys + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * import scipy.spatial.distance */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 - * try: - * _import_array() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.multiarray failed to import") - * + /* "saliency_mbd.pyx":4 + * import numpy as np + * cimport numpy as np + * import scipy.spatial.distance # <<<<<<<<<<<<<< + * import skimage + * import skimage.io */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1036, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_spatial_distance, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_scipy, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 - * _import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_umath() except -1: + /* "saliency_mbd.pyx":5 + * cimport numpy as np + * import scipy.spatial.distance + * import skimage # <<<<<<<<<<<<<< + * import skimage.io + * from skimage.util import img_as_float */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1037, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1037, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; + __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: + /* "saliency_mbd.pyx":6 + * import scipy.spatial.distance + * import skimage + * import skimage.io # <<<<<<<<<<<<<< + * from skimage.util import img_as_float + * from scipy.optimize import minimize */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } + __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage_io, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * _import_array() + /* "saliency_mbd.pyx":7 + * import skimage + * import skimage.io + * from skimage.util import img_as_float # <<<<<<<<<<<<<< + * from scipy.optimize import minimize + * cimport cython */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_img_as_float); + __Pyx_GIVEREF(__pyx_n_s_img_as_float); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_img_as_float); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_skimage_util, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_img_as_float, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + /* "saliency_mbd.pyx":8 + * import skimage.io + * from skimage.util import img_as_float + * from scipy.optimize import minimize # <<<<<<<<<<<<<< + * cimport cython + * from libc.math cimport exp, floor, sqrt */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_minimize); + __Pyx_GIVEREF(__pyx_n_s_minimize); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_minimize); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_optimize, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_minimize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_minimize, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; -static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_umath", 0); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 - * cdef inline int import_umath() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") - */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1041, __pyx_L3_error) - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + /* "saliency_mbd.pyx":12 + * from libc.math cimport exp, floor, sqrt * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") + * np.import_array() # <<<<<<<<<<<<<< * + * @cython.boundscheck(False) */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1042, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 12, __pyx_L1_error) - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":127 + * return D * - * cdef inline int import_ufunc() except -1: + * def f(x): # <<<<<<<<<<<<<< + * b = 10.0 + * return 1.0 / (1.0 + exp(-b*(x - 0.5))) */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1043, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1043, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12saliency_mbd_1f, NULL, __pyx_n_s_saliency_mbd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_f, __pyx_t_1) < 0) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + /* "saliency_mbd.pyx":1 + * import sys # <<<<<<<<<<<<<< + * import numpy as np + * cimport numpy as np */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039 - * raise ImportError("numpy.core.multiarray failed to import") + /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 + * raise ImportError("numpy.core.umath failed to import") * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ - /* function exit code */ - __pyx_r = 0; + /*--- Wrapped vars code ---*/ + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init saliency_mbd"); + } __pyx_L0:; __Pyx_RefNannyFinishContext(); - return __pyx_r; + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif } -/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - -static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_ufunc", 0); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 - * cdef inline int import_ufunc() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") - */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1047, __pyx_L3_error) +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; + return result; +} - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") - */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1048, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1049, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1049, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyMethodDef __pyx_methods[] = { - {"get_saliency_mbd", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_12saliency_mbd_3get_saliency_mbd, METH_VARARGS|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_saliency_mbd(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_saliency_mbd}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "saliency_mbd", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, - {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, - {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, - {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, - {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, - {&__pyx_n_s_T, __pyx_k_T, sizeof(__pyx_k_T), 0, 0, 1, 1}, - {&__pyx_n_s_VI, __pyx_k_VI, sizeof(__pyx_k_VI), 0, 0, 1, 1}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_n_s_arange, __pyx_k_arange, sizeof(__pyx_k_arange), 0, 0, 1, 1}, - {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1}, - {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, - {&__pyx_n_s_cdist, __pyx_k_cdist, sizeof(__pyx_k_cdist), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_color, __pyx_k_color, sizeof(__pyx_k_color), 0, 0, 1, 1}, - {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, - {&__pyx_n_s_cov, __pyx_k_cov, sizeof(__pyx_k_cov), 0, 0, 1, 1}, - {&__pyx_n_s_distance, __pyx_k_distance, sizeof(__pyx_k_distance), 0, 0, 1, 1}, - {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1}, - {&__pyx_n_s_full_like, __pyx_k_full_like, sizeof(__pyx_k_full_like), 0, 0, 1, 1}, - {&__pyx_n_s_img, __pyx_k_img, sizeof(__pyx_k_img), 0, 0, 1, 1}, - {&__pyx_n_s_img_as_float, __pyx_k_img_as_float, sizeof(__pyx_k_img_as_float), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_inv, __pyx_k_inv, sizeof(__pyx_k_inv), 0, 0, 1, 1}, - {&__pyx_n_s_linalg, __pyx_k_linalg, sizeof(__pyx_k_linalg), 0, 0, 1, 1}, - {&__pyx_n_s_mahalanobis, __pyx_k_mahalanobis, sizeof(__pyx_k_mahalanobis), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, - {&__pyx_n_s_maximum, __pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 0, 1, 1}, - {&__pyx_n_s_mean, __pyx_k_mean, sizeof(__pyx_k_mean), 0, 0, 1, 1}, - {&__pyx_n_s_meshgrid, __pyx_k_meshgrid, sizeof(__pyx_k_meshgrid), 0, 0, 1, 1}, - {&__pyx_n_s_method, __pyx_k_method, sizeof(__pyx_k_method), 0, 0, 1, 1}, - {&__pyx_n_s_minimize, __pyx_k_minimize, sizeof(__pyx_k_minimize), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, - {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, - {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, - {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, - {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, - {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_reshape, __pyx_k_reshape, sizeof(__pyx_k_reshape), 0, 0, 1, 1}, - {&__pyx_n_s_rgb2lab, __pyx_k_rgb2lab, sizeof(__pyx_k_rgb2lab), 0, 0, 1, 1}, - {&__pyx_n_s_saliency_mbd, __pyx_k_saliency_mbd, sizeof(__pyx_k_saliency_mbd), 0, 0, 1, 1}, - {&__pyx_kp_s_saliency_mbd_pyx, __pyx_k_saliency_mbd_pyx, sizeof(__pyx_k_saliency_mbd_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_scipy, __pyx_k_scipy, sizeof(__pyx_k_scipy), 0, 0, 1, 1}, - {&__pyx_n_s_scipy_optimize, __pyx_k_scipy_optimize, sizeof(__pyx_k_scipy_optimize), 0, 0, 1, 1}, - {&__pyx_n_s_scipy_spatial_distance, __pyx_k_scipy_spatial_distance, sizeof(__pyx_k_scipy_spatial_distance), 0, 0, 1, 1}, - {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, - {&__pyx_n_s_skimage, __pyx_k_skimage, sizeof(__pyx_k_skimage), 0, 0, 1, 1}, - {&__pyx_n_s_skimage_io, __pyx_k_skimage_io, sizeof(__pyx_k_skimage_io), 0, 0, 1, 1}, - {&__pyx_n_s_skimage_util, __pyx_k_skimage_util, sizeof(__pyx_k_skimage_util), 0, 0, 1, 1}, - {&__pyx_n_s_spatial, __pyx_k_spatial, sizeof(__pyx_k_spatial), 0, 0, 1, 1}, - {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1}, - {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, - {&__pyx_n_s_vectorize, __pyx_k_vectorize, sizeof(__pyx_k_vectorize), 0, 0, 1, 1}, - {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, - {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 33, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 855, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1037, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "saliency_mbd.pyx":113 - * U = np.copy(img) - * D = np.full_like(img, 10000000) - * D[0,:] = 0 # <<<<<<<<<<<<<< - * D[-1,:] = 0 - * D[:,0] = 0 - */ - __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - __pyx_tuple__2 = PyTuple_Pack(2, __pyx_int_0, __pyx_slice_); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - /* "saliency_mbd.pyx":114 - * D = np.full_like(img, 10000000) - * D[0,:] = 0 - * D[-1,:] = 0 # <<<<<<<<<<<<<< - * D[:,0] = 0 - * D[:,-1] = 0 - */ - __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_neg_1, __pyx_slice_); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 114, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - /* "saliency_mbd.pyx":115 - * D[0,:] = 0 - * D[-1,:] = 0 - * D[:,0] = 0 # <<<<<<<<<<<<<< - * D[:,-1] = 0 - * - */ - __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 115, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - - /* "saliency_mbd.pyx":116 - * D[-1,:] = 0 - * D[:,0] = 0 - * D[:,-1] = 0 # <<<<<<<<<<<<<< - * - * cdef int x - */ - __pyx_tuple__5 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 116, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - - /* "saliency_mbd.pyx":151 - * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] - * - * px_mean_left = np.mean(px_left,axis=(0,1)) # <<<<<<<<<<<<<< - * px_mean_right = np.mean(px_right,axis=(0,1)) - * px_mean_top = np.mean(px_top,axis=(0,1)) - */ - __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - - /* "saliency_mbd.pyx":184 - * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) - * - * px_mean_left_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< - * px_mean_left_2[0,:] = px_mean_left - * - */ - __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_3); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< - * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - */ - __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 272, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< - * - * info.buf = PyArray_DATA(self) - */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< - * - * if ((child.byteorder == c'>' and little_endian) or - */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 855, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< - * - * # Until ticket #99 is fixed, use integers to avoid warnings - */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 879, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 - * _import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_umath() except -1: - */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 1037, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_ufunc() except -1: - */ - __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 1043, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); - - /* "saliency_mbd.pyx":127 - * return D - * - * def f(x): # <<<<<<<<<<<<<< - * b = 10.0 - * return 1.0 / (1.0 + exp(-b*(x - 0.5))) - */ - __pyx_tuple__15 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_b); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); - __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_saliency_mbd_pyx, __pyx_n_s_f, 127, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_float_0_5 = PyFloat_FromDouble(0.5); if (unlikely(!__pyx_float_0_5)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_float_2_0 = PyFloat_FromDouble(2.0); if (unlikely(!__pyx_float_2_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_float_255_0 = PyFloat_FromDouble(255.0); if (unlikely(!__pyx_float_255_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_10000000 = PyInt_FromLong(10000000L); if (unlikely(!__pyx_int_10000000)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", - #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), - #else - sizeof(PyHeapTypeObject), - #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) - __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 917, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initsaliency_mbd(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initsaliency_mbd(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { - result = PyDict_SetItemString(moddict, to_name, value); - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { - PyObject *module = NULL, *moddict, *modname; - if (__Pyx_check_single_interpreter()) - return NULL; - if (__pyx_m) - return __Pyx_NewRef(__pyx_m); - modname = PyObject_GetAttrString(spec, "name"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_saliency_mbd(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'saliency_mbd' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_saliency_mbd(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - #ifdef WITH_THREAD /* Python build with threading support? */ - PyEval_InitThreads(); - #endif - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("saliency_mbd", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_saliency_mbd) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "saliency_mbd")) { - if (unlikely(PyDict_SetItemString(modules, "saliency_mbd", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - (void)__Pyx_modinit_type_init_code(); - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "saliency_mbd.pyx":1 - * import sys # <<<<<<<<<<<<<< - * import numpy as np - * cimport numpy as np - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "saliency_mbd.pyx":2 - * import sys - * import numpy as np # <<<<<<<<<<<<<< - * cimport numpy as np - * import scipy.spatial.distance - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "saliency_mbd.pyx":4 - * import numpy as np - * cimport numpy as np - * import scipy.spatial.distance # <<<<<<<<<<<<<< - * import skimage - * import skimage.io - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_spatial_distance, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_scipy, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "saliency_mbd.pyx":5 - * cimport numpy as np - * import scipy.spatial.distance - * import skimage # <<<<<<<<<<<<<< - * import skimage.io - * from skimage.util import img_as_float - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "saliency_mbd.pyx":6 - * import scipy.spatial.distance - * import skimage - * import skimage.io # <<<<<<<<<<<<<< - * from skimage.util import img_as_float - * from scipy.optimize import minimize - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage_io, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "saliency_mbd.pyx":7 - * import skimage - * import skimage.io - * from skimage.util import img_as_float # <<<<<<<<<<<<<< - * from scipy.optimize import minimize - * cimport cython - */ - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_img_as_float); - __Pyx_GIVEREF(__pyx_n_s_img_as_float); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_img_as_float); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_skimage_util, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_img_as_float, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "saliency_mbd.pyx":8 - * import skimage.io - * from skimage.util import img_as_float - * from scipy.optimize import minimize # <<<<<<<<<<<<<< - * cimport cython - * from libc.math cimport exp, floor, sqrt - */ - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_minimize); - __Pyx_GIVEREF(__pyx_n_s_minimize); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_minimize); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_optimize, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_minimize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_minimize, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "saliency_mbd.pyx":12 - * from libc.math cimport exp, floor, sqrt - * - * np.import_array() # <<<<<<<<<<<<<< - * - * @cython.boundscheck(False) - */ - __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 12, __pyx_L1_error) - - /* "saliency_mbd.pyx":127 - * return D - * - * def f(x): # <<<<<<<<<<<<<< - * b = 10.0 - * return 1.0 / (1.0 + exp(-b*(x - 0.5))) - */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12saliency_mbd_1f, NULL, __pyx_n_s_saliency_mbd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_f, __pyx_t_1) < 0) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "saliency_mbd.pyx":1 - * import sys # <<<<<<<<<<<<<< - * import numpy as np - * cimport numpy as np - */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init saliency_mbd"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} - -/* --- Runtime support code --- */ -/* Refnanny */ -#if CYTHON_REFNANNY -static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { - PyObject *m = NULL, *p = NULL; - void *r = NULL; - m = PyImport_ImportModule(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); - if (!p) goto end; - r = PyLong_AsVoidPtr(p); -end: - Py_XDECREF(p); - Py_XDECREF(m); - return (__Pyx_RefNannyAPIStruct *)r; -} -#endif - -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif - -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* IsLittleEndian */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) -{ - union { - uint32_t u32; - uint8_t u8[4]; - } S; - S.u32 = 0x01020304; - return S.u8[0] == 4; -} - -/* BufferFormatCheck */ -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type) { - stack[0].field = &ctx->root; - stack[0].parent_offset = 0; - ctx->root.type = type; - ctx->root.name = "buffer dtype"; - ctx->root.offset = 0; - ctx->head = stack; - ctx->head->field = &ctx->root; - ctx->fmt_offset = 0; - ctx->head->parent_offset = 0; - ctx->new_packmode = '@'; - ctx->enc_packmode = '@'; - ctx->new_count = 1; - ctx->enc_count = 0; - ctx->enc_type = 0; - ctx->is_complex = 0; - ctx->is_valid_array = 0; - ctx->struct_alignment = 0; - while (type->typegroup == 'S') { - ++ctx->head; - ctx->head->field = type->fields; - ctx->head->parent_offset = 0; - type = type->fields->type; - } -} -static int __Pyx_BufFmt_ParseNumber(const char** ts) { - int count; - const char* t = *ts; - if (*t < '0' || *t > '9') { - return -1; - } else { - count = *t++ - '0'; - while (*t >= '0' && *t <= '9') { - count *= 10; - count += *t++ - '0'; - } - } - *ts = t; - return count; -} -static int __Pyx_BufFmt_ExpectNumber(const char **ts) { - int number = __Pyx_BufFmt_ParseNumber(ts); - if (number == -1) - PyErr_Format(PyExc_ValueError,\ - "Does not understand character buffer dtype format string ('%c')", **ts); - return number; -} -static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { - PyErr_Format(PyExc_ValueError, - "Unexpected format string character: '%c'", ch); -} -static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { - switch (ch) { - case '?': return "'bool'"; - case 'c': return "'char'"; - case 'b': return "'signed char'"; - case 'B': return "'unsigned char'"; - case 'h': return "'short'"; - case 'H': return "'unsigned short'"; - case 'i': return "'int'"; - case 'I': return "'unsigned int'"; - case 'l': return "'long'"; - case 'L': return "'unsigned long'"; - case 'q': return "'long long'"; - case 'Q': return "'unsigned long long'"; - case 'f': return (is_complex ? "'complex float'" : "'float'"); - case 'd': return (is_complex ? "'complex double'" : "'double'"); - case 'g': return (is_complex ? "'complex long double'" : "'long double'"); - case 'T': return "a struct"; - case 'O': return "Python object"; - case 'P': return "a pointer"; - case 's': case 'p': return "a string"; - case 0: return "end"; - default: return "unparseable format string"; - } -} -static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return 2; - case 'i': case 'I': case 'l': case 'L': return 4; - case 'q': case 'Q': return 8; - case 'f': return (is_complex ? 8 : 4); - case 'd': return (is_complex ? 16 : 8); - case 'g': { - PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); - return 0; - } - case 'O': case 'P': return sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(short); - case 'i': case 'I': return sizeof(int); - case 'l': case 'L': return sizeof(long); - #ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(PY_LONG_LONG); - #endif - case 'f': return sizeof(float) * (is_complex ? 2 : 1); - case 'd': return sizeof(double) * (is_complex ? 2 : 1); - case 'g': return sizeof(long double) * (is_complex ? 2 : 1); - case 'O': case 'P': return sizeof(void*); - default: { - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } - } -} -typedef struct { char c; short x; } __Pyx_st_short; -typedef struct { char c; int x; } __Pyx_st_int; -typedef struct { char c; long x; } __Pyx_st_long; -typedef struct { char c; float x; } __Pyx_st_float; -typedef struct { char c; double x; } __Pyx_st_double; -typedef struct { char c; long double x; } __Pyx_st_longdouble; -typedef struct { char c; void *x; } __Pyx_st_void_p; -#ifdef HAVE_LONG_LONG -typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; -#endif -static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); - case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); - case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); -#ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); -#endif - case 'f': return sizeof(__Pyx_st_float) - sizeof(float); - case 'd': return sizeof(__Pyx_st_double) - sizeof(double); - case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); - case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -/* These are for computing the padding at the end of the struct to align - on the first member of the struct. This will probably the same as above, - but we don't have any guarantees. - */ -typedef struct { short x; char c; } __Pyx_pad_short; -typedef struct { int x; char c; } __Pyx_pad_int; -typedef struct { long x; char c; } __Pyx_pad_long; -typedef struct { float x; char c; } __Pyx_pad_float; -typedef struct { double x; char c; } __Pyx_pad_double; -typedef struct { long double x; char c; } __Pyx_pad_longdouble; -typedef struct { void *x; char c; } __Pyx_pad_void_p; -#ifdef HAVE_LONG_LONG -typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; -#endif -static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); - case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); - case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); -#ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); -#endif - case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); - case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); - case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); - case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { - switch (ch) { - case 'c': - return 'H'; - case 'b': case 'h': case 'i': - case 'l': case 'q': case 's': case 'p': - return 'I'; - case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': - return 'U'; - case 'f': case 'd': case 'g': - return (is_complex ? 'C' : 'R'); - case 'O': - return 'O'; - case 'P': - return 'P'; - default: { - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } - } -} -static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { - if (ctx->head == NULL || ctx->head->field == &ctx->root) { - const char* expected; - const char* quote; - if (ctx->head == NULL) { - expected = "end"; - quote = ""; - } else { - expected = ctx->head->field->type->name; - quote = "'"; - } - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch, expected %s%s%s but got %s", - quote, expected, quote, - __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); - } else { - __Pyx_StructField* field = ctx->head->field; - __Pyx_StructField* parent = (ctx->head - 1)->field; - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", - field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), - parent->type->name, field->name); - } -} -static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { - char group; - size_t size, offset, arraysize = 1; - if (ctx->enc_type == 0) return 0; - if (ctx->head->field->type->arraysize[0]) { - int i, ndim = 0; - if (ctx->enc_type == 's' || ctx->enc_type == 'p') { - ctx->is_valid_array = ctx->head->field->type->ndim == 1; - ndim = 1; - if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { - PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %zu", - ctx->head->field->type->arraysize[0], ctx->enc_count); - return -1; - } - } - if (!ctx->is_valid_array) { - PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", - ctx->head->field->type->ndim, ndim); - return -1; - } - for (i = 0; i < ctx->head->field->type->ndim; i++) { - arraysize *= ctx->head->field->type->arraysize[i]; - } - ctx->is_valid_array = 0; - ctx->enc_count = 1; - } - group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); - do { - __Pyx_StructField* field = ctx->head->field; - __Pyx_TypeInfo* type = field->type; - if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { - size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); - } else { - size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); - } - if (ctx->enc_packmode == '@') { - size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); - size_t align_mod_offset; - if (align_at == 0) return -1; - align_mod_offset = ctx->fmt_offset % align_at; - if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; - if (ctx->struct_alignment == 0) - ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, - ctx->is_complex); - } - if (type->size != size || type->typegroup != group) { - if (type->typegroup == 'C' && type->fields != NULL) { - size_t parent_offset = ctx->head->parent_offset + field->offset; - ++ctx->head; - ctx->head->field = type->fields; - ctx->head->parent_offset = parent_offset; - continue; - } - if ((type->typegroup == 'H' || group == 'H') && type->size == size) { - } else { - __Pyx_BufFmt_RaiseExpected(ctx); - return -1; - } - } - offset = ctx->head->parent_offset + field->offset; - if (ctx->fmt_offset != offset) { - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", - (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); - return -1; - } - ctx->fmt_offset += size; - if (arraysize) - ctx->fmt_offset += (arraysize - 1) * size; - --ctx->enc_count; - while (1) { - if (field == &ctx->root) { - ctx->head = NULL; - if (ctx->enc_count != 0) { - __Pyx_BufFmt_RaiseExpected(ctx); - return -1; - } - break; - } - ctx->head->field = ++field; - if (field->type == NULL) { - --ctx->head; - field = ctx->head->field; - continue; - } else if (field->type->typegroup == 'S') { - size_t parent_offset = ctx->head->parent_offset + field->offset; - if (field->type->fields->type == NULL) continue; - field = field->type->fields; - ++ctx->head; - ctx->head->field = field; - ctx->head->parent_offset = parent_offset; - break; - } else { - break; - } - } - } while (ctx->enc_count); - ctx->enc_type = 0; - ctx->is_complex = 0; - return 0; -} -static PyObject * -__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) -{ - const char *ts = *tsp; - int i = 0, number, ndim; - ++ts; - if (ctx->new_count != 1) { - PyErr_SetString(PyExc_ValueError, - "Cannot handle repeated arrays in format string"); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ndim = ctx->head->field->type->ndim; - while (*ts && *ts != ')') { - switch (*ts) { - case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; - default: break; - } - number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) - return PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %d", - ctx->head->field->type->arraysize[i], number); - if (*ts != ',' && *ts != ')') - return PyErr_Format(PyExc_ValueError, - "Expected a comma in format string, got '%c'", *ts); - if (*ts == ',') ts++; - i++; - } - if (i != ndim) - return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", - ctx->head->field->type->ndim, i); - if (!*ts) { - PyErr_SetString(PyExc_ValueError, - "Unexpected end of format string, expected ')'"); - return NULL; - } - ctx->is_valid_array = 1; - ctx->new_count = 1; - *tsp = ++ts; - return Py_None; -} -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { - int got_Z = 0; - while (1) { - switch(*ts) { - case 0: - if (ctx->enc_type != 0 && ctx->head == NULL) { - __Pyx_BufFmt_RaiseExpected(ctx); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - if (ctx->head != NULL) { - __Pyx_BufFmt_RaiseExpected(ctx); - return NULL; - } - return ts; - case ' ': - case '\r': - case '\n': - ++ts; - break; - case '<': - if (!__Pyx_Is_Little_Endian()) { - PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); - return NULL; - } - ctx->new_packmode = '='; - ++ts; - break; - case '>': - case '!': - if (__Pyx_Is_Little_Endian()) { - PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); - return NULL; - } - ctx->new_packmode = '='; - ++ts; - break; - case '=': - case '@': - case '^': - ctx->new_packmode = *ts++; - break; - case 'T': - { - const char* ts_after_sub; - size_t i, struct_count = ctx->new_count; - size_t struct_alignment = ctx->struct_alignment; - ctx->new_count = 1; - ++ts; - if (*ts != '{') { - PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_type = 0; - ctx->enc_count = 0; - ctx->struct_alignment = 0; - ++ts; - ts_after_sub = ts; - for (i = 0; i != struct_count; ++i) { - ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); - if (!ts_after_sub) return NULL; - } - ts = ts_after_sub; - if (struct_alignment) ctx->struct_alignment = struct_alignment; - } - break; - case '}': - { - size_t alignment = ctx->struct_alignment; - ++ts; - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_type = 0; - if (alignment && ctx->fmt_offset % alignment) { - ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); - } - } - return ts; - case 'x': - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->fmt_offset += ctx->new_count; - ctx->new_count = 1; - ctx->enc_count = 0; - ctx->enc_type = 0; - ctx->enc_packmode = ctx->new_packmode; - ++ts; - break; - case 'Z': - got_Z = 1; - ++ts; - if (*ts != 'f' && *ts != 'd' && *ts != 'g') { - __Pyx_BufFmt_RaiseUnexpectedChar('Z'); - return NULL; - } - CYTHON_FALLTHROUGH; - case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': - case 'l': case 'L': case 'q': case 'Q': - case 'f': case 'd': case 'g': - case 'O': case 'p': - if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && - (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { - ctx->enc_count += ctx->new_count; - ctx->new_count = 1; - got_Z = 0; - ++ts; - break; - } - CYTHON_FALLTHROUGH; - case 's': - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_count = ctx->new_count; - ctx->enc_packmode = ctx->new_packmode; - ctx->enc_type = *ts; - ctx->is_complex = got_Z; - ++ts; - ctx->new_count = 1; - got_Z = 0; - break; - case ':': - ++ts; - while(*ts != ':') ++ts; - ++ts; - break; - case '(': - if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; - break; - default: - { - int number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - ctx->new_count = (size_t)number; - } - } - } -} - -/* BufferGetAndValidate */ - static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { - if (unlikely(info->buf == NULL)) return; - if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; - __Pyx_ReleaseBuffer(info); -} -static void __Pyx_ZeroBuffer(Py_buffer* buf) { - buf->buf = NULL; - buf->obj = NULL; - buf->strides = __Pyx_zeros; - buf->shape = __Pyx_zeros; - buf->suboffsets = __Pyx_minusones; -} -static int __Pyx__GetBufferAndValidate( - Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, - int nd, int cast, __Pyx_BufFmt_StackElem* stack) +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { - buf->buf = NULL; - if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { - __Pyx_ZeroBuffer(buf); - return -1; - } - if (unlikely(buf->ndim != nd)) { - PyErr_Format(PyExc_ValueError, - "Buffer has wrong number of dimensions (expected %d, got %d)", - nd, buf->ndim); - goto fail; - } - if (!cast) { - __Pyx_BufFmt_Context ctx; - __Pyx_BufFmt_Init(&ctx, stack, dtype); - if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; - } - if (unlikely((size_t)buf->itemsize != dtype->size)) { - PyErr_Format(PyExc_ValueError, - "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", - buf->itemsize, (buf->itemsize > 1) ? "s" : "", - dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); - goto fail; - } - if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; - return 0; -fail:; - __Pyx_SafeReleaseBuffer(buf); - return -1; + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; } -/* GetItemInt */ - static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (!j) return NULL; - r = PyObject_GetItem(o, j); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyList_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { - PyObject *r = PyList_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyTuple_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); - } - } - return m->sq_item(o, i); +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; } } -#else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); - } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + *ts = t; + return count; } - -/* SetItemInt */ - static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { - int r; - if (!j) return -1; - r = PyObject_SetItem(o, j, v); - Py_DECREF(j); - return r; +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; } -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, - CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { - PyObject* old = PyList_GET_ITEM(o, n); - Py_INCREF(v); - PyList_SET_ITEM(o, n, v); - Py_DECREF(old); - return 1; - } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_ass_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return -1; - PyErr_Clear(); - } - } - return m->sq_ass_item(o, i, v); - } +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; } -#else -#if CYTHON_COMPILING_IN_PYPY - if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) -#else - if (is_list || PySequence_Check(o)) -#endif - { - return PySequence_SetItem(o, i, v); + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; } -#endif - return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); -} - -/* PyErrFetchRestore */ - #if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); } -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } } +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif - -/* PyDictVersioning */ - #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } } -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } } -#endif - -/* GetModuleGlobalName */ - #if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* PyCFunctionFastCall */ - #if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { - PyCFunctionObject *func = (PyCFunctionObject*)func_obj; - PyCFunction meth = PyCFunction_GET_FUNCTION(func); - PyObject *self = PyCFunction_GET_SELF(func); - int flags = PyCFunction_GET_FLAGS(func); - assert(PyCFunction_Check(func)); - assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); - assert(nargs >= 0); - assert(nargs == 0 || args != NULL); - /* _PyCFunction_FastCallDict() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } -} -#endif - -/* PyFunctionFastCall */ - #if CYTHON_FAST_PYCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; } -#if 1 || PY_VERSION_HEX < 0x030600B1 -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); return NULL; } - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; } - } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; } - nk = i / 2; - } - else { - kwtuple = NULL; - k = NULL; - } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; + } } -#endif -#endif -/* PyObjectCall */ - #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = func->ob_type->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} +static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + buf->buf = NULL; + if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; } -#endif -/* PyObjectCall2Args */ - static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { - PyObject *args, *result = NULL; - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyFunction_FastCall(function, args, 2); +/* GetItemInt */ + static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; } - #endif - args = PyTuple_New(2); - if (unlikely(!args)) goto done; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - Py_INCREF(function); - result = __Pyx_PyObject_Call(function, args, NULL); - Py_DECREF(args); - Py_DECREF(function); -done: - return result; + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif } - -/* PyObjectCallMethO */ - #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = cfunc(self, arg); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); } - return result; -} + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); #endif - -/* PyObjectCallOneArg */ - #if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; } -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } } -#endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); } } - return __Pyx__PyObject_CallOneArg(func, arg); -} #else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } #endif - -/* None */ - static CYTHON_INLINE long __Pyx_mod_long(long a, long b) { - long r = a % b; - r += ((r != 0) & ((r ^ b) < 0)) * b; - return r; + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } -/* ExtTypeTest */ - static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", - Py_TYPE(obj)->tp_name, type->tp_name); - return 0; +/* SetItemInt */ + static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (!j) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; } - -/* PyFloatBinop */ - #if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { - const double b = floatval; - double a, result; - (void)inplace; - (void)zerodivision_check; - if (likely(PyFloat_CheckExact(op1))) { - a = PyFloat_AS_DOUBLE(op1); - - } else - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - a = (double) PyInt_AS_LONG(op1); - - } else - #endif - if (likely(PyLong_CheckExact(op1))) { - #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)op1)->ob_digit; - const Py_ssize_t size = Py_SIZE(op1); - switch (size) { - case 0: a = 0.0; break; - case -1: a = -(double) digits[0]; break; - case 1: a = (double) digits[0]; break; - case -2: - case 2: - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) { - a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { - if (size == -2) - a = -a; - break; - } - } - CYTHON_FALLTHROUGH; - case -3: - case 3: - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) { - a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { - if (size == -3) - a = -a; - break; - } - } - CYTHON_FALLTHROUGH; - case -4: - case 4: - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) { - a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { - if (size == -4) - a = -a; - break; - } +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); } - CYTHON_FALLTHROUGH; - default: - #else - { - #endif - a = PyLong_AsDouble(op1); - if (unlikely(a == -1.0 && PyErr_Occurred())) return NULL; - + } + return m->sq_ass_item(o, i, v); } - } else { - return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); } - - PyFPE_START_PROTECT("subtract", return NULL) - result = a - b; - PyFPE_END_PROTECT(result) - return PyFloat_FromDouble(result); +#else +#if CYTHON_COMPILING_IN_PYPY + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) +#else + if (is_list || PySequence_Check(o)) +#endif + { + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; } #endif -/* PyIntFromDouble */ - #if PY_MAJOR_VERSION < 3 -static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value) { - if (value >= (double)LONG_MIN && value <= (double)LONG_MAX) { - return PyInt_FromLong((long)value); +/* PyDictVersioning */ + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif } - return PyLong_FromDouble(value); + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif -/* ObjectGetItem */ - #if CYTHON_USE_TYPE_SLOTS -static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { - PyObject *runerr; - Py_ssize_t key_value; - PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; - if (unlikely(!(m && m->sq_item))) { - PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); +/* GetModuleGlobalName */ + #if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { return NULL; } - key_value = __Pyx_PyIndex_AsSsize_t(index); - if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { - return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); } - if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { - PyErr_Clear(); - PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); } - return NULL; + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); } -static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { - PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; - if (likely(m && m->mp_subscript)) { - return m->mp_subscript(obj, key); + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } - return __Pyx_PyObject_GetIndex(obj, key); } #endif -/* PyIntBinop */ - #if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { - (void)inplace; - (void)zerodivision_check; - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - const long b = intval; - long x; - long a = PyInt_AS_LONG(op1); - x = (long)((unsigned long)a - b); - if (likely((x^a) >= 0 || (x^~b) >= 0)) - return PyInt_FromLong(x); - return PyLong_Type.tp_as_number->nb_subtract(op1, op2); +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; } - #endif - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(PyLong_CheckExact(op1))) { - const long b = intval; - long a, x; -#ifdef HAVE_LONG_LONG - const PY_LONG_LONG llb = intval; - PY_LONG_LONG lla, llx; -#endif - const digit* digits = ((PyLongObject*)op1)->ob_digit; - const Py_ssize_t size = Py_SIZE(op1); - if (likely(__Pyx_sst_abs(size) <= 1)) { - a = likely(size) ? digits[0] : 0; - if (size == -1) a = -a; - } else { - switch (size) { - case -2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; #endif - } - CYTHON_FALLTHROUGH; - case 2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && #endif - } - CYTHON_FALLTHROUGH; - case -3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif - } - CYTHON_FALLTHROUGH; - case 3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); #endif - } - CYTHON_FALLTHROUGH; - case -4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} #endif - } - CYTHON_FALLTHROUGH; - case 4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; #endif - } - CYTHON_FALLTHROUGH; - default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); - } - } - x = a - b; - return PyLong_FromLong(x); -#ifdef HAVE_LONG_LONG - long_long: - llx = lla - llb; - return PyLong_FromLongLong(llx); + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} #endif - - + +/* PyObjectCall2Args */ + static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); } #endif - if (PyFloat_CheckExact(op1)) { - const long b = intval; - double a = PyFloat_AS_DOUBLE(op1); - double result; - PyFPE_START_PROTECT("subtract", return NULL) - result = ((double)a) - (double)b; - PyFPE_END_PROTECT(result) - return PyFloat_FromDouble(result); + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); } - return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; } -#endif -/* RaiseTooManyValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; } +#endif -/* RaiseNeedMoreValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; } - -/* IterFinish */ - static CYTHON_INLINE int __Pyx_IterFinish(void) { -#if CYTHON_FAST_THREAD_STATE - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* exc_type = tstate->curexc_type; - if (unlikely(exc_type)) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { - PyObject *exc_value, *exc_tb; - exc_value = tstate->curexc_value; - exc_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; - Py_DECREF(exc_type); - Py_XDECREF(exc_value); - Py_XDECREF(exc_tb); - return 0; - } else { - return -1; - } +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); } - return 0; -#else - if (unlikely(PyErr_Occurred())) { - if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { - PyErr_Clear(); - return 0; - } else { - return -1; +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif } } - return 0; + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} #endif + +/* None */ + static CYTHON_INLINE long __Pyx_mod_long(long a, long b) { + long r = a % b; + r += ((r != 0) & ((r ^ b) < 0)) * b; + return r; } -/* UnpackItemEndCheck */ - static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { - if (unlikely(retval)) { - Py_DECREF(retval); - __Pyx_RaiseTooManyValuesError(expected); - return -1; - } else { - return __Pyx_IterFinish(); +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* PyFloatBinop */ - #if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { const double b = floatval; double a, result; (void)inplace; @@ -10941,142 +7816,18 @@ static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double f } } else { - return (inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2)); + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); } - PyFPE_START_PROTECT("divide", return NULL) - result = a / b; + PyFPE_START_PROTECT("subtract", return NULL) + result = a - b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } #endif -/* PyIntBinop */ - #if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { - (void)inplace; - (void)zerodivision_check; - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op2))) { - const long a = intval; - long x; - long b = PyInt_AS_LONG(op2); - x = (long)((unsigned long)a - b); - if (likely((x^a) >= 0 || (x^~b) >= 0)) - return PyInt_FromLong(x); - return PyLong_Type.tp_as_number->nb_subtract(op1, op2); - } - #endif - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(PyLong_CheckExact(op2))) { - const long a = intval; - long b, x; -#ifdef HAVE_LONG_LONG - const PY_LONG_LONG lla = intval; - PY_LONG_LONG llb, llx; -#endif - const digit* digits = ((PyLongObject*)op2)->ob_digit; - const Py_ssize_t size = Py_SIZE(op2); - if (likely(__Pyx_sst_abs(size) <= 1)) { - b = likely(size) ? digits[0] : 0; - if (size == -1) b = -b; - } else { - switch (size) { - case -2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - b = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - llb = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case 2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - b = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - llb = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case -3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - b = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - llb = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case 3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - b = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - llb = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case -4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - b = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - llb = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case 4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - b = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - llb = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); - } - } - x = a - b; - return PyLong_FromLong(x); -#ifdef HAVE_LONG_LONG - long_long: - llx = lla - llb; - return PyLong_FromLongLong(llx); -#endif - - - } - #endif - if (PyFloat_CheckExact(op2)) { - const long a = intval; - double b = PyFloat_AS_DOUBLE(op2); - double result; - PyFPE_START_PROTECT("subtract", return NULL) - result = ((double)a) - (double)b; - PyFPE_END_PROTECT(result) - return PyFloat_FromDouble(result); - } - return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); -} -#endif - /* RaiseDoubleKeywords */ - static void __Pyx_RaiseDoubleKeywordsError( + static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { @@ -11090,7 +7841,7 @@ static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, CYTHON_U } /* ParseKeywords */ - static int __Pyx_ParseOptionalKeywords( + static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, @@ -11192,7 +7943,7 @@ static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, CYTHON_U } /* RaiseArgTupleInvalid */ - static void __Pyx_RaiseArgtupleInvalid( + static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, @@ -11218,7 +7969,7 @@ static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, CYTHON_U } /* ArgTypeTest */ - static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) + static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); @@ -11239,7 +7990,7 @@ static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, CYTHON_U } /* RaiseException */ - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare @@ -11398,7 +8149,7 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject #endif /* DictGetItem */ - #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY + #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); @@ -11421,13 +8172,26 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { } #endif +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + /* RaiseNoneIterError */ - static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* GetTopmostException */ - #if CYTHON_USE_EXC_INFO_STACK + #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { @@ -11442,7 +8206,7 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) #endif /* SaveResetException */ - #if CYTHON_FAST_THREAD_STATE + #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); @@ -11483,7 +8247,7 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject #endif /* PyErrExceptionMatches */ - #if CYTHON_FAST_THREAD_STATE + #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); @@ -11508,7 +8272,7 @@ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tsta #endif /* GetException */ - #if CYTHON_FAST_THREAD_STATE + #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) @@ -11582,7 +8346,7 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) } /* TypeImport */ - #ifndef __PYX_HAVE_RT_ImportType + #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) @@ -11643,7 +8407,7 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, #endif /* Import */ - static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; @@ -11708,7 +8472,7 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, } /* ImportFrom */ - static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, @@ -11722,7 +8486,7 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, } /* CLineInTraceback */ - #ifndef CYTHON_CLINE_IN_TRACEBACK + #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; @@ -11764,7 +8528,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ - static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; @@ -11844,7 +8608,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { } /* AddTraceback */ - #include "compile.h" + #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( @@ -11950,8 +8714,8 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif - /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + /* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { @@ -11982,7 +8746,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { } /* CIntFromPyVerify */ - #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) @@ -12004,7 +8768,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { } /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { @@ -12034,39 +8798,8 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { } } -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) { - const Py_intptr_t neg_one = (Py_intptr_t) ((Py_intptr_t) 0 - (Py_intptr_t) 1), const_zero = (Py_intptr_t) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(Py_intptr_t) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(Py_intptr_t) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t), - little, !is_unsigned); - } -} - /* Declarations */ - #if CYTHON_CCOMPLEX + #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); @@ -12086,7 +8819,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif /* Arithmetic */ - #if CYTHON_CCOMPLEX + #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); @@ -12220,7 +8953,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif /* Declarations */ - #if CYTHON_CCOMPLEX + #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); @@ -12240,7 +8973,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif /* Arithmetic */ - #if CYTHON_CCOMPLEX + #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); @@ -12374,7 +9107,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { @@ -12405,7 +9138,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { } /* CIntFromPy */ - static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 @@ -12594,7 +9327,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { } /* CIntFromPy */ - static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 @@ -12783,7 +9516,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { } /* FastTypeChecks */ - #if CYTHON_COMPILING_IN_CPYTHON + #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; @@ -12883,7 +9616,7 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ - static int __Pyx_check_binary_version(void) { + static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); @@ -12899,7 +9632,7 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj } /* InitStrings */ - static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { diff --git a/perception/vis/vis.py b/perception/vis/vis.py index 99b353a..a347618 100644 --- a/perception/vis/vis.py +++ b/perception/vis/vis.py @@ -12,7 +12,7 @@ def run(data_sources, algorithm, save_video=False): out = None window_builder = Visualizer(algorithm.kwargs) - data = FrameWrapper(data_sources, 0.25) + data = FrameWrapper(data_sources, 0.1) frame_count = 0 speed = 1 From db0149ebe3bbad6fad0955519ee14bf993d33889 Mon Sep 17 00:00:00 2001 From: Karthik Dharmarajan Date: Sun, 14 Feb 2021 17:12:23 -0800 Subject: [PATCH 21/43] Removed experiment --- perception/tasks/segmentation/COMB_SAL_BG.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py index f53214c..1d86c72 100644 --- a/perception/tasks/segmentation/COMB_SAL_BG.py +++ b/perception/tasks/segmentation/COMB_SAL_BG.py @@ -39,6 +39,4 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]): sal = self.sal.analyze(frame, debug, slider_vals=slider_vals) bg = self.bg.analyze(frame,debug, slider_vals=slider_vals) ret = cv.bitwise_and(sal[0],bg[0]) - contours = cv.findContours(ret, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_NONE) - cv.drawContours(ret, contours[1], -1, (0,255,0), 3) return frame, [frame, sal[0], bg[0], ret] \ No newline at end of file From 3698801b89ec1f49d4aa030aef09c54ce47677cd Mon Sep 17 00:00:00 2001 From: ayush0624 <31373700+ayush0624@users.noreply.github.com> Date: Sun, 14 Feb 2021 17:16:25 -0800 Subject: [PATCH 22/43] added build firle --- .../saliency_mbd.o | Bin 683332 -> 240808 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.7/saliency_mbd.o b/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.7/saliency_mbd.o index aa514436db8e242d734dd05c2388b308c45cdecf..9de7be1be1d86a9a9c46ee3ab15ae72c1d0d5cc4 100644 GIT binary patch literal 240808 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 ^tOo5?BRZP>g1Rm0V&Hlt0LdX&Vg*sYH7# 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∾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 PYySCM1f&rg67qill95-& literal 683332 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
}t(5R+ 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 From 96f7662eb7717c2fed15974e14029c47e72caacb Mon Sep 17 00:00:00 2001 From: Shrey A Date: Sun, 14 Feb 2021 18:25:16 -0800 Subject: [PATCH 23/43] use numpy oriented C functions for better cython performance Next steps include adding support for skimage, cython views (maybe) --- .../saliency_detection/saliency_mbd.c | 9197 ++++++++++------- .../saliency_detection/saliency_mbd.html | 2017 ++-- .../saliency_detection/saliency_mbd.pyx | 94 +- 3 files changed, 6711 insertions(+), 4597 deletions(-) diff --git a/perception/tasks/segmentation/saliency_detection/saliency_mbd.c b/perception/tasks/segmentation/saliency_detection/saliency_mbd.c index bc3627f..b960a3d 100644 --- a/perception/tasks/segmentation/saliency_detection/saliency_mbd.c +++ b/perception/tasks/segmentation/saliency_detection/saliency_mbd.c @@ -1,18 +1,5 @@ /* Generated by Cython 0.29.21 */ -/* BEGIN: Cython Metadata -{ - "distutils": { - "depends": [], - "name": "saliency_mbd", - "sources": [ - "/Users/karthikdharmarajan/Documents/URobotics/perception/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx" - ] - }, - "module_name": "saliency_mbd" -} -END: Cython Metadata */ - #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H @@ -622,6 +609,9 @@ static CYTHON_INLINE float __PYX_NAN() { #include #include "numpy/arrayobject.h" #include "numpy/ufuncobject.h" + + /* NumPy API declarations from "numpy/__init__.pxd" */ + #include #ifdef _OPENMP #include @@ -853,8 +843,9 @@ static const char *__pyx_filename; static const char *__pyx_f[] = { - "tasks/segmentation/saliency_detection/saliency_mbd.pyx", + "perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx", "__init__.pxd", + "stringsource", "type.pxd", }; /* BufferFormatStructs.proto */ @@ -894,7 +885,7 @@ typedef struct { } __Pyx_BufFmt_Context; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":775 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":689 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -903,7 +894,7 @@ typedef struct { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":690 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -912,7 +903,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":691 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -921,7 +912,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":692 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -930,7 +921,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":696 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -939,7 +930,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":697 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -948,7 +939,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":698 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -957,7 +948,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":699 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -966,7 +957,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":789 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":703 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -975,7 +966,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":704 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -984,7 +975,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":713 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -993,7 +984,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":714 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -1002,7 +993,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":715 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -1011,7 +1002,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":717 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -1020,7 +1011,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":718 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -1029,7 +1020,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":719 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -1038,7 +1029,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":807 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":721 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -1047,7 +1038,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":722 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -1056,7 +1047,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":810 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":724 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -1065,7 +1056,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":725 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -1074,7 +1065,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":726 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -1108,8 +1099,9 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do /*--- Type declarations ---*/ +struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":728 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -1118,7 +1110,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":729 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -1127,7 +1119,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":730 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -1136,7 +1128,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":732 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -1146,9 +1138,9 @@ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; typedef npy_cdouble __pyx_t_5numpy_complex_t; struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd; -/* "saliency_mbd.pyx":132 - * +/* "saliency_mbd.pyx":133 * @cython.boundscheck(False) + * @cython.wraparound(False) * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS * img_mean = np.mean(img,axis=(2)) @@ -1158,6 +1150,19 @@ struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd { PyObject *method; }; +/* "cfunc.to_py":64 + * + * @cname("__Pyx_CFunc_object____object___to_py") + * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ): # <<<<<<<<<<<<<< + * def wrap(object x): + * """wrap(x)""" + */ +struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py { + PyObject_HEAD + PyObject *(*__pyx_v_f)(PyObject *); +}; + + /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY @@ -1253,38 +1258,7 @@ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; -/* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ - __Pyx_GetItemInt_Generic(o, to_py_func(i)))) -#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, - int is_list, int wraparound, int boundscheck); - -/* SetItemInt.proto */ -#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ - __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) -static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, - int is_list, int wraparound, int boundscheck); - +#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; @@ -1416,12 +1390,12 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); -/* None.proto */ -static CYTHON_INLINE long __Pyx_mod_long(long, long); - /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); +/* None.proto */ +static CYTHON_INLINE long __Pyx_mod_long(long, long); + /* PyFloatBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); @@ -1430,6 +1404,70 @@ static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) #endif +/* PyIntFromDouble.proto */ +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value); +#else +#define __Pyx_PyInt_FromDouble(value) PyLong_FromDouble(value) +#endif + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_SubtractCObj(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); @@ -1448,29 +1486,6 @@ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* DictGetItem.proto */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); -#define __Pyx_PyObject_Dict_GetItem(obj, name)\ - (likely(PyDict_CheckExact(obj)) ?\ - __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) -#else -#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) -#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) -#endif - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); - /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); @@ -1503,6 +1518,82 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED 1 +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + size_t defaults_size; // used by FusedFunction for copying defaults + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType)) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* IncludeStringH.proto */ +#include + +/* PyObject_GenericGetAttrNoDict.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +#endif + /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto @@ -1575,6 +1666,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value); + /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus @@ -1673,9 +1767,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); #endif #endif -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); - /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); @@ -1729,7 +1820,6 @@ static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; -static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/ /* Module declarations from 'cython' */ @@ -1737,106 +1827,138 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/ /* Module declarations from 'libc.math' */ /* Module declarations from 'saliency_mbd' */ +static PyTypeObject *__pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____object___to_py = 0; static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *, PyArrayObject *, PyArrayObject *, PyArrayObject *); /*proto*/ static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *, PyArrayObject *, PyArrayObject *, PyArrayObject *); /*proto*/ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *, int); /*proto*/ +static PyObject *__pyx_f_12saliency_mbd_f(PyObject *); /*proto*/ static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd *__pyx_optional_args); /*proto*/ +static PyObject *__Pyx_CFunc_object____object___to_py(PyObject *(*)(PyObject *)); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "saliency_mbd" extern int __pyx_module_is_main_saliency_mbd; int __pyx_module_is_main_saliency_mbd = 0; /* Implementation of 'saliency_mbd' */ -static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin_ValueError; -static PyObject *__pyx_builtin_RuntimeError; +static PyObject *__pyx_builtin_xrange; static PyObject *__pyx_builtin_ImportError; +static const char __pyx_k_T[] = "T"; static const char __pyx_k_b[] = "b"; -static const char __pyx_k_f[] = "f"; static const char __pyx_k_x[] = "x"; +static const char __pyx_k_VI[] = "VI"; static const char __pyx_k_np[] = "np"; +static const char __pyx_k_cov[] = "cov"; static const char __pyx_k_img[] = "img"; +static const char __pyx_k_inv[] = "inv"; +static const char __pyx_k_max[] = "max"; static const char __pyx_k_sys[] = "sys"; static const char __pyx_k_axis[] = "axis"; static const char __pyx_k_copy[] = "copy"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mean[] = "mean"; static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_sqrt[] = "sqrt"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_wrap[] = "wrap"; +static const char __pyx_k_cdist[] = "cdist"; +static const char __pyx_k_color[] = "color"; static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_power[] = "power"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_scipy[] = "scipy"; +static const char __pyx_k_shape[] = "shape"; +static const char __pyx_k_zeros[] = "zeros"; +static const char __pyx_k_arange[] = "arange"; static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_linalg[] = "linalg"; static const char __pyx_k_method[] = "method"; +static const char __pyx_k_xrange[] = "xrange"; +static const char __pyx_k_maximum[] = "maximum"; +static const char __pyx_k_reshape[] = "reshape"; +static const char __pyx_k_rgb2lab[] = "rgb2lab"; static const char __pyx_k_skimage[] = "skimage"; +static const char __pyx_k_spatial[] = "spatial"; +static const char __pyx_k_distance[] = "distance"; +static const char __pyx_k_meshgrid[] = "meshgrid"; static const char __pyx_k_minimize[] = "minimize"; static const char __pyx_k_full_like[] = "full_like"; -static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_vectorize[] = "vectorize"; static const char __pyx_k_skimage_io[] = "skimage.io"; static const char __pyx_k_ImportError[] = "ImportError"; -static const char __pyx_k_RuntimeError[] = "RuntimeError"; +static const char __pyx_k_cfunc_to_py[] = "cfunc.to_py"; +static const char __pyx_k_mahalanobis[] = "mahalanobis"; static const char __pyx_k_img_as_float[] = "img_as_float"; -static const char __pyx_k_saliency_mbd[] = "saliency_mbd"; static const char __pyx_k_skimage_util[] = "skimage.util"; +static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_scipy_optimize[] = "scipy.optimize"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_scipy_spatial_distance[] = "scipy.spatial.distance"; -static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static const char __pyx_k_Pyx_CFunc_object____object___t[] = "__Pyx_CFunc_object____object___to_py..wrap"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; -static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; -static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; -static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; -static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; -static const char __pyx_k_tasks_segmentation_saliency_dete[] = "tasks/segmentation/saliency_detection/saliency_mbd.pyx"; -static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; -static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; -static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; -static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; -static PyObject *__pyx_n_s_RuntimeError; -static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_Pyx_CFunc_object____object___t; +static PyObject *__pyx_n_s_T; +static PyObject *__pyx_n_s_VI; +static PyObject *__pyx_n_s_arange; static PyObject *__pyx_n_s_axis; static PyObject *__pyx_n_s_b; +static PyObject *__pyx_n_s_cdist; +static PyObject *__pyx_n_s_cfunc_to_py; static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_color; static PyObject *__pyx_n_s_copy; -static PyObject *__pyx_n_s_f; +static PyObject *__pyx_n_s_cov; +static PyObject *__pyx_n_s_distance; static PyObject *__pyx_n_s_full_like; static PyObject *__pyx_n_s_img; static PyObject *__pyx_n_s_img_as_float; static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_inv; +static PyObject *__pyx_n_s_linalg; +static PyObject *__pyx_n_s_mahalanobis; static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_max; +static PyObject *__pyx_n_s_maximum; static PyObject *__pyx_n_s_mean; +static PyObject *__pyx_n_s_meshgrid; static PyObject *__pyx_n_s_method; static PyObject *__pyx_n_s_minimize; static PyObject *__pyx_n_s_name; -static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; -static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_n_s_power; static PyObject *__pyx_n_s_range; -static PyObject *__pyx_n_s_saliency_mbd; +static PyObject *__pyx_n_s_reshape; +static PyObject *__pyx_n_s_rgb2lab; static PyObject *__pyx_n_s_scipy; static PyObject *__pyx_n_s_scipy_optimize; static PyObject *__pyx_n_s_scipy_spatial_distance; +static PyObject *__pyx_n_s_shape; static PyObject *__pyx_n_s_skimage; static PyObject *__pyx_n_s_skimage_io; static PyObject *__pyx_n_s_skimage_util; +static PyObject *__pyx_n_s_spatial; +static PyObject *__pyx_n_s_sqrt; +static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_sys; -static PyObject *__pyx_kp_s_tasks_segmentation_saliency_dete; static PyObject *__pyx_n_s_test; -static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_n_s_vectorize; +static PyObject *__pyx_n_s_wrap; static PyObject *__pyx_n_s_x; -static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ -static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method); /* proto */ -static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_n_s_xrange; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_12saliency_mbd_get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method); /* proto */ +static PyObject *__pyx_pf_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap(PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____object___to_py(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_float_0_5; static PyObject *__pyx_float_255_0; static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; static PyObject *__pyx_int_10000000; static PyObject *__pyx_int_neg_1; static PyObject *__pyx_slice_; @@ -1849,25 +1971,22 @@ static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; -static PyObject *__pyx_tuple__11; -static PyObject *__pyx_tuple__12; -static PyObject *__pyx_tuple__13; -static PyObject *__pyx_codeobj__14; +static PyObject *__pyx_codeobj__11; /* Late includes */ -/* "saliency_mbd.pyx":15 - * +/* "saliency_mbd.pyx":16 * @cython.boundscheck(False) + * @cython.wraparound(False) * cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): # <<<<<<<<<<<<<< - * cdef int n_rows - * cdef int n_cols + * # cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double) + * cdef int n_rows = img.shape[0] */ static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) { int __pyx_v_n_rows; int __pyx_v_n_cols; - int __pyx_v_x; - int __pyx_v_y; + Py_ssize_t __pyx_v_x; + Py_ssize_t __pyx_v_y; double __pyx_v_ix; double __pyx_v_d; double __pyx_v_u1; @@ -1886,22 +2005,20 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, __Pyx_Buffer __pyx_pybuffer_img; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - long __pyx_t_3; + long __pyx_t_1; + long __pyx_t_2; + Py_ssize_t __pyx_t_3; long __pyx_t_4; - int __pyx_t_5; - long __pyx_t_6; - long __pyx_t_7; - int __pyx_t_8; - PyObject *__pyx_t_9 = NULL; + long __pyx_t_5; + Py_ssize_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + double __pyx_t_9; double __pyx_t_10; - long __pyx_t_11; + double __pyx_t_11; double __pyx_t_12; - double __pyx_t_13; - double __pyx_t_14; - int __pyx_t_15; - int __pyx_t_16; + int __pyx_t_13; + int __pyx_t_14; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -1924,246 +2041,207 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error) } __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error) } __pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error) } __pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error) } __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; - /* "saliency_mbd.pyx":19 - * cdef int n_cols - * - * n_rows = len(img) # <<<<<<<<<<<<<< - * n_cols = len(img[0]) + /* "saliency_mbd.pyx":18 + * cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): + * # cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double) + * cdef int n_rows = img.shape[0] # <<<<<<<<<<<<<< + * cdef int n_cols = img.shape[1] * */ - __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_img)); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) - __pyx_v_n_rows = __pyx_t_1; + __pyx_v_n_rows = (__pyx_v_img->dimensions[0]); - /* "saliency_mbd.pyx":20 + /* "saliency_mbd.pyx":19 + * # cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double) + * cdef int n_rows = img.shape[0] + * cdef int n_cols = img.shape[1] # <<<<<<<<<<<<<< * - * n_rows = len(img) - * n_cols = len(img[0]) # <<<<<<<<<<<<<< * - * cdef int x */ - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_n_cols = __pyx_t_1; + __pyx_v_n_cols = (__pyx_v_img->dimensions[1]); - /* "saliency_mbd.pyx":33 + /* "saliency_mbd.pyx":32 * cdef double b2 * - * for x in range(1,n_rows - 1): # <<<<<<<<<<<<<< - * for y in range(1,n_cols - 1): - * ix = img[x][y] + * for x in xrange(1,n_rows - 1): # <<<<<<<<<<<<<< + * for y in xrange(1,n_cols - 1): + * ix = img[x, y] + */ + __pyx_t_1 = (__pyx_v_n_rows - 1); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 1; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_x = __pyx_t_3; + + /* "saliency_mbd.pyx":33 + * + * for x in xrange(1,n_rows - 1): + * for y in xrange(1,n_cols - 1): # <<<<<<<<<<<<<< + * ix = img[x, y] + * d = D[x,y] */ - __pyx_t_3 = (__pyx_v_n_rows - 1); - __pyx_t_4 = __pyx_t_3; - for (__pyx_t_5 = 1; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_x = __pyx_t_5; + __pyx_t_4 = (__pyx_v_n_cols - 1); + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 1; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_y = __pyx_t_6; - /* "saliency_mbd.pyx":34 + /* "saliency_mbd.pyx":34 + * for x in xrange(1,n_rows - 1): + * for y in xrange(1,n_cols - 1): + * ix = img[x, y] # <<<<<<<<<<<<<< + * d = D[x,y] * - * for x in range(1,n_rows - 1): - * for y in range(1,n_cols - 1): # <<<<<<<<<<<<<< - * ix = img[x][y] - * d = D[x][y] */ - __pyx_t_6 = (__pyx_v_n_cols - 1); - __pyx_t_7 = __pyx_t_6; - for (__pyx_t_8 = 1; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { - __pyx_v_y = __pyx_t_8; + __pyx_t_7 = __pyx_v_x; + __pyx_t_8 = __pyx_v_y; + __pyx_v_ix = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_img.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_img.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_img.diminfo[1].strides)); /* "saliency_mbd.pyx":35 - * for x in range(1,n_rows - 1): - * for y in range(1,n_cols - 1): - * ix = img[x][y] # <<<<<<<<<<<<<< - * d = D[x][y] - * - */ - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 35, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_ix = __pyx_t_10; - - /* "saliency_mbd.pyx":36 - * for y in range(1,n_cols - 1): - * ix = img[x][y] - * d = D[x][y] # <<<<<<<<<<<<<< - * - * u1 = U[x-1][y] - */ - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_d = __pyx_t_10; + * for y in xrange(1,n_cols - 1): + * ix = img[x, y] + * d = D[x,y] # <<<<<<<<<<<<<< + * + * u1 = U[x-1,y] + */ + __pyx_t_8 = __pyx_v_x; + __pyx_t_7 = __pyx_v_y; + __pyx_v_d = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_D.diminfo[1].strides)); - /* "saliency_mbd.pyx":38 - * d = D[x][y] + /* "saliency_mbd.pyx":37 + * d = D[x,y] * - * u1 = U[x-1][y] # <<<<<<<<<<<<<< - * l1 = L[x-1][y] + * u1 = U[x-1,y] # <<<<<<<<<<<<<< + * l1 = L[x-1,y] * */ - __pyx_t_11 = (__pyx_v_x - 1); - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_u1 = __pyx_t_10; + __pyx_t_7 = (__pyx_v_x - 1); + __pyx_t_8 = __pyx_v_y; + __pyx_v_u1 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_U.diminfo[1].strides)); - /* "saliency_mbd.pyx":39 + /* "saliency_mbd.pyx":38 * - * u1 = U[x-1][y] - * l1 = L[x-1][y] # <<<<<<<<<<<<<< + * u1 = U[x-1,y] + * l1 = L[x-1,y] # <<<<<<<<<<<<<< * - * u2 = U[x][y-1] + * u2 = U[x,y-1] */ - __pyx_t_11 = (__pyx_v_x - 1); - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_l1 = __pyx_t_10; + __pyx_t_8 = (__pyx_v_x - 1); + __pyx_t_7 = __pyx_v_y; + __pyx_v_l1 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_L.diminfo[1].strides)); - /* "saliency_mbd.pyx":41 - * l1 = L[x-1][y] + /* "saliency_mbd.pyx":40 + * l1 = L[x-1,y] * - * u2 = U[x][y-1] # <<<<<<<<<<<<<< - * l2 = L[x][y-1] + * u2 = U[x,y-1] # <<<<<<<<<<<<<< + * l2 = L[x,y-1] * */ - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_11 = (__pyx_v_y - 1); - __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 41, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_u2 = __pyx_t_10; + __pyx_t_7 = __pyx_v_x; + __pyx_t_8 = (__pyx_v_y - 1); + __pyx_v_u2 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_U.diminfo[1].strides)); - /* "saliency_mbd.pyx":42 + /* "saliency_mbd.pyx":41 * - * u2 = U[x][y-1] - * l2 = L[x][y-1] # <<<<<<<<<<<<<< + * u2 = U[x,y-1] + * l2 = L[x,y-1] # <<<<<<<<<<<<<< * * b1 = max(u1,ix) - min(l1,ix) */ - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_11 = (__pyx_v_y - 1); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_l2 = __pyx_t_10; + __pyx_t_8 = __pyx_v_x; + __pyx_t_7 = (__pyx_v_y - 1); + __pyx_v_l2 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_L.diminfo[1].strides)); - /* "saliency_mbd.pyx":44 - * l2 = L[x][y-1] + /* "saliency_mbd.pyx":43 + * l2 = L[x,y-1] * * b1 = max(u1,ix) - min(l1,ix) # <<<<<<<<<<<<<< * b2 = max(u2,ix) - min(l2,ix) * */ - __pyx_t_10 = __pyx_v_ix; - __pyx_t_12 = __pyx_v_u1; - if (((__pyx_t_10 > __pyx_t_12) != 0)) { - __pyx_t_13 = __pyx_t_10; + __pyx_t_9 = __pyx_v_ix; + __pyx_t_10 = __pyx_v_u1; + if (((__pyx_t_9 > __pyx_t_10) != 0)) { + __pyx_t_11 = __pyx_t_9; } else { - __pyx_t_13 = __pyx_t_12; + __pyx_t_11 = __pyx_t_10; } - __pyx_t_10 = __pyx_v_ix; - __pyx_t_12 = __pyx_v_l1; - if (((__pyx_t_10 < __pyx_t_12) != 0)) { - __pyx_t_14 = __pyx_t_10; + __pyx_t_9 = __pyx_v_ix; + __pyx_t_10 = __pyx_v_l1; + if (((__pyx_t_9 < __pyx_t_10) != 0)) { + __pyx_t_12 = __pyx_t_9; } else { - __pyx_t_14 = __pyx_t_12; + __pyx_t_12 = __pyx_t_10; } - __pyx_v_b1 = (__pyx_t_13 - __pyx_t_14); + __pyx_v_b1 = (__pyx_t_11 - __pyx_t_12); - /* "saliency_mbd.pyx":45 + /* "saliency_mbd.pyx":44 * * b1 = max(u1,ix) - min(l1,ix) * b2 = max(u2,ix) - min(l2,ix) # <<<<<<<<<<<<<< * * if d <= b1 and d <= b2: */ - __pyx_t_14 = __pyx_v_ix; - __pyx_t_13 = __pyx_v_u2; - if (((__pyx_t_14 > __pyx_t_13) != 0)) { - __pyx_t_10 = __pyx_t_14; + __pyx_t_12 = __pyx_v_ix; + __pyx_t_11 = __pyx_v_u2; + if (((__pyx_t_12 > __pyx_t_11) != 0)) { + __pyx_t_9 = __pyx_t_12; } else { - __pyx_t_10 = __pyx_t_13; + __pyx_t_9 = __pyx_t_11; } - __pyx_t_14 = __pyx_v_ix; - __pyx_t_13 = __pyx_v_l2; - if (((__pyx_t_14 < __pyx_t_13) != 0)) { - __pyx_t_12 = __pyx_t_14; + __pyx_t_12 = __pyx_v_ix; + __pyx_t_11 = __pyx_v_l2; + if (((__pyx_t_12 < __pyx_t_11) != 0)) { + __pyx_t_10 = __pyx_t_12; } else { - __pyx_t_12 = __pyx_t_13; + __pyx_t_10 = __pyx_t_11; } - __pyx_v_b2 = (__pyx_t_10 - __pyx_t_12); + __pyx_v_b2 = (__pyx_t_9 - __pyx_t_10); - /* "saliency_mbd.pyx":47 + /* "saliency_mbd.pyx":46 * b2 = max(u2,ix) - min(l2,ix) * * if d <= b1 and d <= b2: # <<<<<<<<<<<<<< * continue * elif b1 < d and b1 <= b2: */ - __pyx_t_16 = ((__pyx_v_d <= __pyx_v_b1) != 0); - if (__pyx_t_16) { + __pyx_t_14 = ((__pyx_v_d <= __pyx_v_b1) != 0); + if (__pyx_t_14) { } else { - __pyx_t_15 = __pyx_t_16; + __pyx_t_13 = __pyx_t_14; goto __pyx_L8_bool_binop_done; } - __pyx_t_16 = ((__pyx_v_d <= __pyx_v_b2) != 0); - __pyx_t_15 = __pyx_t_16; + __pyx_t_14 = ((__pyx_v_d <= __pyx_v_b2) != 0); + __pyx_t_13 = __pyx_t_14; __pyx_L8_bool_binop_done:; - if (__pyx_t_15) { + if (__pyx_t_13) { - /* "saliency_mbd.pyx":48 + /* "saliency_mbd.pyx":47 * * if d <= b1 and d <= b2: * continue # <<<<<<<<<<<<<< * elif b1 < d and b1 <= b2: - * D[x][y] = b1 + * D[x,y] = b1 */ goto __pyx_L5_continue; - /* "saliency_mbd.pyx":47 + /* "saliency_mbd.pyx":46 * b2 = max(u2,ix) - min(l2,ix) * * if d <= b1 and d <= b2: # <<<<<<<<<<<<<< @@ -2172,160 +2250,136 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, */ } - /* "saliency_mbd.pyx":49 + /* "saliency_mbd.pyx":48 * if d <= b1 and d <= b2: * continue * elif b1 < d and b1 <= b2: # <<<<<<<<<<<<<< - * D[x][y] = b1 - * U[x][y] = max(u1,ix) + * D[x,y] = b1 + * U[x,y] = max(u1,ix) */ - __pyx_t_16 = ((__pyx_v_b1 < __pyx_v_d) != 0); - if (__pyx_t_16) { + __pyx_t_14 = ((__pyx_v_b1 < __pyx_v_d) != 0); + if (__pyx_t_14) { } else { - __pyx_t_15 = __pyx_t_16; + __pyx_t_13 = __pyx_t_14; goto __pyx_L10_bool_binop_done; } - __pyx_t_16 = ((__pyx_v_b1 <= __pyx_v_b2) != 0); - __pyx_t_15 = __pyx_t_16; + __pyx_t_14 = ((__pyx_v_b1 <= __pyx_v_b2) != 0); + __pyx_t_13 = __pyx_t_14; __pyx_L10_bool_binop_done:; - if (__pyx_t_15) { + if (__pyx_t_13) { - /* "saliency_mbd.pyx":50 + /* "saliency_mbd.pyx":49 * continue * elif b1 < d and b1 <= b2: - * D[x][y] = b1 # <<<<<<<<<<<<<< - * U[x][y] = max(u1,ix) - * L[x][y] = min(l1,ix) - */ - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + * D[x,y] = b1 # <<<<<<<<<<<<<< + * U[x,y] = max(u1,ix) + * L[x,y] = min(l1,ix) + */ + __pyx_t_7 = __pyx_v_x; + __pyx_t_8 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_D.diminfo[1].strides) = __pyx_v_b1; - /* "saliency_mbd.pyx":51 + /* "saliency_mbd.pyx":50 * elif b1 < d and b1 <= b2: - * D[x][y] = b1 - * U[x][y] = max(u1,ix) # <<<<<<<<<<<<<< - * L[x][y] = min(l1,ix) + * D[x,y] = b1 + * U[x,y] = max(u1,ix) # <<<<<<<<<<<<<< + * L[x,y] = min(l1,ix) * else: */ - __pyx_t_12 = __pyx_v_ix; - __pyx_t_10 = __pyx_v_u1; - if (((__pyx_t_12 > __pyx_t_10) != 0)) { - __pyx_t_14 = __pyx_t_12; + __pyx_t_10 = __pyx_v_ix; + __pyx_t_9 = __pyx_v_u1; + if (((__pyx_t_10 > __pyx_t_9) != 0)) { + __pyx_t_12 = __pyx_t_10; } else { - __pyx_t_14 = __pyx_t_10; + __pyx_t_12 = __pyx_t_9; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 51, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 51, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "saliency_mbd.pyx":52 - * D[x][y] = b1 - * U[x][y] = max(u1,ix) - * L[x][y] = min(l1,ix) # <<<<<<<<<<<<<< + __pyx_t_8 = __pyx_v_x; + __pyx_t_7 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_U.diminfo[1].strides) = __pyx_t_12; + + /* "saliency_mbd.pyx":51 + * D[x,y] = b1 + * U[x,y] = max(u1,ix) + * L[x,y] = min(l1,ix) # <<<<<<<<<<<<<< * else: - * D[x][y] = b2 + * D[x,y] = b2 */ - __pyx_t_14 = __pyx_v_ix; - __pyx_t_12 = __pyx_v_l1; - if (((__pyx_t_14 < __pyx_t_12) != 0)) { - __pyx_t_10 = __pyx_t_14; + __pyx_t_12 = __pyx_v_ix; + __pyx_t_10 = __pyx_v_l1; + if (((__pyx_t_12 < __pyx_t_10) != 0)) { + __pyx_t_9 = __pyx_t_12; } else { - __pyx_t_10 = __pyx_t_12; + __pyx_t_9 = __pyx_t_10; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = __pyx_v_x; + __pyx_t_8 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_L.diminfo[1].strides) = __pyx_t_9; - /* "saliency_mbd.pyx":49 + /* "saliency_mbd.pyx":48 * if d <= b1 and d <= b2: * continue * elif b1 < d and b1 <= b2: # <<<<<<<<<<<<<< - * D[x][y] = b1 - * U[x][y] = max(u1,ix) + * D[x,y] = b1 + * U[x,y] = max(u1,ix) */ goto __pyx_L7; } - /* "saliency_mbd.pyx":54 - * L[x][y] = min(l1,ix) + /* "saliency_mbd.pyx":53 + * L[x,y] = min(l1,ix) * else: - * D[x][y] = b2 # <<<<<<<<<<<<<< - * U[x][y] = max(u2,ix) - * L[x][y] = min(l2,ix) + * D[x,y] = b2 # <<<<<<<<<<<<<< + * U[x,y] = max(u2,ix) + * L[x,y] = min(l2,ix) */ /*else*/ { - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __pyx_v_x; + __pyx_t_7 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_D.diminfo[1].strides) = __pyx_v_b2; - /* "saliency_mbd.pyx":55 + /* "saliency_mbd.pyx":54 * else: - * D[x][y] = b2 - * U[x][y] = max(u2,ix) # <<<<<<<<<<<<<< - * L[x][y] = min(l2,ix) + * D[x,y] = b2 + * U[x,y] = max(u2,ix) # <<<<<<<<<<<<<< + * L[x,y] = min(l2,ix) * */ - __pyx_t_10 = __pyx_v_ix; - __pyx_t_14 = __pyx_v_u2; - if (((__pyx_t_10 > __pyx_t_14) != 0)) { - __pyx_t_12 = __pyx_t_10; + __pyx_t_9 = __pyx_v_ix; + __pyx_t_12 = __pyx_v_u2; + if (((__pyx_t_9 > __pyx_t_12) != 0)) { + __pyx_t_10 = __pyx_t_9; } else { - __pyx_t_12 = __pyx_t_14; + __pyx_t_10 = __pyx_t_12; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "saliency_mbd.pyx":56 - * D[x][y] = b2 - * U[x][y] = max(u2,ix) - * L[x][y] = min(l2,ix) # <<<<<<<<<<<<<< + __pyx_t_7 = __pyx_v_x; + __pyx_t_8 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_U.diminfo[1].strides) = __pyx_t_10; + + /* "saliency_mbd.pyx":55 + * D[x,y] = b2 + * U[x,y] = max(u2,ix) + * L[x,y] = min(l2,ix) # <<<<<<<<<<<<<< * * return True */ - __pyx_t_12 = __pyx_v_ix; - __pyx_t_10 = __pyx_v_l2; - if (((__pyx_t_12 < __pyx_t_10) != 0)) { - __pyx_t_14 = __pyx_t_12; + __pyx_t_10 = __pyx_v_ix; + __pyx_t_9 = __pyx_v_l2; + if (((__pyx_t_10 < __pyx_t_9) != 0)) { + __pyx_t_12 = __pyx_t_10; } else { - __pyx_t_14 = __pyx_t_10; + __pyx_t_12 = __pyx_t_9; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __pyx_v_x; + __pyx_t_7 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_L.diminfo[1].strides) = __pyx_t_12; } __pyx_L7:; __pyx_L5_continue:; } } - /* "saliency_mbd.pyx":58 - * L[x][y] = min(l2,ix) + /* "saliency_mbd.pyx":57 + * L[x,y] = min(l2,ix) * * return True # <<<<<<<<<<<<<< * @@ -2336,18 +2390,16 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, __pyx_r = Py_True; goto __pyx_L0; - /* "saliency_mbd.pyx":15 - * + /* "saliency_mbd.pyx":16 * @cython.boundscheck(False) + * @cython.wraparound(False) * cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): # <<<<<<<<<<<<<< - * cdef int n_rows - * cdef int n_cols + * # cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double) + * cdef int n_rows = img.shape[0] */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_9); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -2372,8 +2424,8 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, } /* "saliency_mbd.pyx":61 - * * @cython.boundscheck(False) + * @cython.wraparound(False) * cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): # <<<<<<<<<<<<<< * cdef int n_rows * cdef int n_cols @@ -2382,8 +2434,8 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) { int __pyx_v_n_rows; int __pyx_v_n_cols; - int __pyx_v_x; - int __pyx_v_y; + Py_ssize_t __pyx_v_x; + Py_ssize_t __pyx_v_y; double __pyx_v_ix; double __pyx_v_d; double __pyx_v_u1; @@ -2403,17 +2455,15 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_i PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + double __pyx_t_5; double __pyx_t_6; - long __pyx_t_7; + double __pyx_t_7; double __pyx_t_8; - double __pyx_t_9; - double __pyx_t_10; - int __pyx_t_11; - int __pyx_t_12; + int __pyx_t_9; + int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -2441,237 +2491,198 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_i __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) } __pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) } __pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error) } __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; /* "saliency_mbd.pyx":65 * cdef int n_cols * - * n_rows = len(img) # <<<<<<<<<<<<<< - * n_cols = len(img[0]) + * n_rows = img.shape[0] # <<<<<<<<<<<<<< + * n_cols = img.shape[1] * */ - __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_img)); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 65, __pyx_L1_error) - __pyx_v_n_rows = __pyx_t_1; + __pyx_v_n_rows = (__pyx_v_img->dimensions[0]); /* "saliency_mbd.pyx":66 * - * n_rows = len(img) - * n_cols = len(img[0]) # <<<<<<<<<<<<<< + * n_rows = img.shape[0] + * n_cols = img.shape[1] # <<<<<<<<<<<<<< * - * cdef int x + * cdef Py_ssize_t x, y */ - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 66, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_n_cols = __pyx_t_1; + __pyx_v_n_cols = (__pyx_v_img->dimensions[1]); - /* "saliency_mbd.pyx":79 + /* "saliency_mbd.pyx":78 * cdef double b2 * - * for x in range(n_rows - 2,1,-1): # <<<<<<<<<<<<<< - * for y in range(n_cols - 2,1,-1): + * for x in xrange(n_rows - 2,1,-1): # <<<<<<<<<<<<<< + * for y in xrange(n_cols - 2,1,-1): * */ - for (__pyx_t_3 = (__pyx_v_n_rows - 2); __pyx_t_3 > 1; __pyx_t_3-=1) { - __pyx_v_x = __pyx_t_3; + for (__pyx_t_1 = (__pyx_v_n_rows - 2); __pyx_t_1 > 1; __pyx_t_1-=1) { + __pyx_v_x = __pyx_t_1; - /* "saliency_mbd.pyx":80 + /* "saliency_mbd.pyx":79 * - * for x in range(n_rows - 2,1,-1): - * for y in range(n_cols - 2,1,-1): # <<<<<<<<<<<<<< + * for x in xrange(n_rows - 2,1,-1): + * for y in xrange(n_cols - 2,1,-1): # <<<<<<<<<<<<<< * - * ix = img[x][y] + * ix = img[x,y] */ - for (__pyx_t_4 = (__pyx_v_n_cols - 2); __pyx_t_4 > 1; __pyx_t_4-=1) { - __pyx_v_y = __pyx_t_4; + for (__pyx_t_2 = (__pyx_v_n_cols - 2); __pyx_t_2 > 1; __pyx_t_2-=1) { + __pyx_v_y = __pyx_t_2; - /* "saliency_mbd.pyx":82 - * for y in range(n_cols - 2,1,-1): + /* "saliency_mbd.pyx":81 + * for y in xrange(n_cols - 2,1,-1): * - * ix = img[x][y] # <<<<<<<<<<<<<< - * d = D[x][y] + * ix = img[x,y] # <<<<<<<<<<<<<< + * d = D[x,y] * */ - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_ix = __pyx_t_6; + __pyx_t_3 = __pyx_v_x; + __pyx_t_4 = __pyx_v_y; + __pyx_v_ix = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_img.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_img.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_img.diminfo[1].strides)); - /* "saliency_mbd.pyx":83 + /* "saliency_mbd.pyx":82 * - * ix = img[x][y] - * d = D[x][y] # <<<<<<<<<<<<<< + * ix = img[x,y] + * d = D[x,y] # <<<<<<<<<<<<<< * - * u1 = U[x+1][y] + * u1 = U[x+1,y] */ - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_d = __pyx_t_6; + __pyx_t_4 = __pyx_v_x; + __pyx_t_3 = __pyx_v_y; + __pyx_v_d = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_D.diminfo[1].strides)); - /* "saliency_mbd.pyx":85 - * d = D[x][y] + /* "saliency_mbd.pyx":84 + * d = D[x,y] * - * u1 = U[x+1][y] # <<<<<<<<<<<<<< - * l1 = L[x+1][y] + * u1 = U[x+1,y] # <<<<<<<<<<<<<< + * l1 = L[x+1,y] * */ - __pyx_t_7 = (__pyx_v_x + 1); - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_u1 = __pyx_t_6; + __pyx_t_3 = (__pyx_v_x + 1); + __pyx_t_4 = __pyx_v_y; + __pyx_v_u1 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_U.diminfo[1].strides)); - /* "saliency_mbd.pyx":86 + /* "saliency_mbd.pyx":85 * - * u1 = U[x+1][y] - * l1 = L[x+1][y] # <<<<<<<<<<<<<< + * u1 = U[x+1,y] + * l1 = L[x+1,y] # <<<<<<<<<<<<<< * - * u2 = U[x][y+1] + * u2 = U[x,y+1] */ - __pyx_t_7 = (__pyx_v_x + 1); - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_l1 = __pyx_t_6; + __pyx_t_4 = (__pyx_v_x + 1); + __pyx_t_3 = __pyx_v_y; + __pyx_v_l1 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_L.diminfo[1].strides)); - /* "saliency_mbd.pyx":88 - * l1 = L[x+1][y] + /* "saliency_mbd.pyx":87 + * l1 = L[x+1,y] * - * u2 = U[x][y+1] # <<<<<<<<<<<<<< - * l2 = L[x][y+1] + * u2 = U[x,y+1] # <<<<<<<<<<<<<< + * l2 = L[x,y+1] * */ - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = (__pyx_v_y + 1); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_u2 = __pyx_t_6; + __pyx_t_3 = __pyx_v_x; + __pyx_t_4 = (__pyx_v_y + 1); + __pyx_v_u2 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_U.diminfo[1].strides)); - /* "saliency_mbd.pyx":89 + /* "saliency_mbd.pyx":88 * - * u2 = U[x][y+1] - * l2 = L[x][y+1] # <<<<<<<<<<<<<< + * u2 = U[x,y+1] + * l2 = L[x,y+1] # <<<<<<<<<<<<<< * * b1 = max(u1,ix) - min(l1,ix) */ - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = (__pyx_v_y + 1); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_l2 = __pyx_t_6; + __pyx_t_4 = __pyx_v_x; + __pyx_t_3 = (__pyx_v_y + 1); + __pyx_v_l2 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_L.diminfo[1].strides)); - /* "saliency_mbd.pyx":91 - * l2 = L[x][y+1] + /* "saliency_mbd.pyx":90 + * l2 = L[x,y+1] * * b1 = max(u1,ix) - min(l1,ix) # <<<<<<<<<<<<<< * b2 = max(u2,ix) - min(l2,ix) * */ - __pyx_t_6 = __pyx_v_ix; - __pyx_t_8 = __pyx_v_u1; - if (((__pyx_t_6 > __pyx_t_8) != 0)) { - __pyx_t_9 = __pyx_t_6; + __pyx_t_5 = __pyx_v_ix; + __pyx_t_6 = __pyx_v_u1; + if (((__pyx_t_5 > __pyx_t_6) != 0)) { + __pyx_t_7 = __pyx_t_5; } else { - __pyx_t_9 = __pyx_t_8; + __pyx_t_7 = __pyx_t_6; } - __pyx_t_6 = __pyx_v_ix; - __pyx_t_8 = __pyx_v_l1; - if (((__pyx_t_6 < __pyx_t_8) != 0)) { - __pyx_t_10 = __pyx_t_6; + __pyx_t_5 = __pyx_v_ix; + __pyx_t_6 = __pyx_v_l1; + if (((__pyx_t_5 < __pyx_t_6) != 0)) { + __pyx_t_8 = __pyx_t_5; } else { - __pyx_t_10 = __pyx_t_8; + __pyx_t_8 = __pyx_t_6; } - __pyx_v_b1 = (__pyx_t_9 - __pyx_t_10); + __pyx_v_b1 = (__pyx_t_7 - __pyx_t_8); - /* "saliency_mbd.pyx":92 + /* "saliency_mbd.pyx":91 * * b1 = max(u1,ix) - min(l1,ix) * b2 = max(u2,ix) - min(l2,ix) # <<<<<<<<<<<<<< * * if d <= b1 and d <= b2: */ - __pyx_t_10 = __pyx_v_ix; - __pyx_t_9 = __pyx_v_u2; - if (((__pyx_t_10 > __pyx_t_9) != 0)) { - __pyx_t_6 = __pyx_t_10; + __pyx_t_8 = __pyx_v_ix; + __pyx_t_7 = __pyx_v_u2; + if (((__pyx_t_8 > __pyx_t_7) != 0)) { + __pyx_t_5 = __pyx_t_8; } else { - __pyx_t_6 = __pyx_t_9; + __pyx_t_5 = __pyx_t_7; } - __pyx_t_10 = __pyx_v_ix; - __pyx_t_9 = __pyx_v_l2; - if (((__pyx_t_10 < __pyx_t_9) != 0)) { - __pyx_t_8 = __pyx_t_10; + __pyx_t_8 = __pyx_v_ix; + __pyx_t_7 = __pyx_v_l2; + if (((__pyx_t_8 < __pyx_t_7) != 0)) { + __pyx_t_6 = __pyx_t_8; } else { - __pyx_t_8 = __pyx_t_9; + __pyx_t_6 = __pyx_t_7; } - __pyx_v_b2 = (__pyx_t_6 - __pyx_t_8); + __pyx_v_b2 = (__pyx_t_5 - __pyx_t_6); - /* "saliency_mbd.pyx":94 + /* "saliency_mbd.pyx":93 * b2 = max(u2,ix) - min(l2,ix) * * if d <= b1 and d <= b2: # <<<<<<<<<<<<<< * continue * elif b1 < d and b1 <= b2: */ - __pyx_t_12 = ((__pyx_v_d <= __pyx_v_b1) != 0); - if (__pyx_t_12) { + __pyx_t_10 = ((__pyx_v_d <= __pyx_v_b1) != 0); + if (__pyx_t_10) { } else { - __pyx_t_11 = __pyx_t_12; + __pyx_t_9 = __pyx_t_10; goto __pyx_L8_bool_binop_done; } - __pyx_t_12 = ((__pyx_v_d <= __pyx_v_b2) != 0); - __pyx_t_11 = __pyx_t_12; + __pyx_t_10 = ((__pyx_v_d <= __pyx_v_b2) != 0); + __pyx_t_9 = __pyx_t_10; __pyx_L8_bool_binop_done:; - if (__pyx_t_11) { + if (__pyx_t_9) { - /* "saliency_mbd.pyx":95 + /* "saliency_mbd.pyx":94 * * if d <= b1 and d <= b2: * continue # <<<<<<<<<<<<<< * elif b1 < d and b1 <= b2: - * D[x][y] = b1 + * D[x,y] = b1 */ goto __pyx_L5_continue; - /* "saliency_mbd.pyx":94 + /* "saliency_mbd.pyx":93 * b2 = max(u2,ix) - min(l2,ix) * * if d <= b1 and d <= b2: # <<<<<<<<<<<<<< @@ -2680,160 +2691,136 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_i */ } - /* "saliency_mbd.pyx":96 + /* "saliency_mbd.pyx":95 * if d <= b1 and d <= b2: * continue * elif b1 < d and b1 <= b2: # <<<<<<<<<<<<<< - * D[x][y] = b1 - * U[x][y] = max(u1,ix) + * D[x,y] = b1 + * U[x,y] = max(u1,ix) */ - __pyx_t_12 = ((__pyx_v_b1 < __pyx_v_d) != 0); - if (__pyx_t_12) { + __pyx_t_10 = ((__pyx_v_b1 < __pyx_v_d) != 0); + if (__pyx_t_10) { } else { - __pyx_t_11 = __pyx_t_12; + __pyx_t_9 = __pyx_t_10; goto __pyx_L10_bool_binop_done; } - __pyx_t_12 = ((__pyx_v_b1 <= __pyx_v_b2) != 0); - __pyx_t_11 = __pyx_t_12; + __pyx_t_10 = ((__pyx_v_b1 <= __pyx_v_b2) != 0); + __pyx_t_9 = __pyx_t_10; __pyx_L10_bool_binop_done:; - if (__pyx_t_11) { + if (__pyx_t_9) { - /* "saliency_mbd.pyx":97 + /* "saliency_mbd.pyx":96 * continue * elif b1 < d and b1 <= b2: - * D[x][y] = b1 # <<<<<<<<<<<<<< - * U[x][y] = max(u1,ix) - * L[x][y] = min(l1,ix) - */ - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + * D[x,y] = b1 # <<<<<<<<<<<<<< + * U[x,y] = max(u1,ix) + * L[x,y] = min(l1,ix) + */ + __pyx_t_3 = __pyx_v_x; + __pyx_t_4 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_D.diminfo[1].strides) = __pyx_v_b1; - /* "saliency_mbd.pyx":98 + /* "saliency_mbd.pyx":97 * elif b1 < d and b1 <= b2: - * D[x][y] = b1 - * U[x][y] = max(u1,ix) # <<<<<<<<<<<<<< - * L[x][y] = min(l1,ix) + * D[x,y] = b1 + * U[x,y] = max(u1,ix) # <<<<<<<<<<<<<< + * L[x,y] = min(l1,ix) * else: */ - __pyx_t_8 = __pyx_v_ix; - __pyx_t_6 = __pyx_v_u1; - if (((__pyx_t_8 > __pyx_t_6) != 0)) { - __pyx_t_10 = __pyx_t_8; + __pyx_t_6 = __pyx_v_ix; + __pyx_t_5 = __pyx_v_u1; + if (((__pyx_t_6 > __pyx_t_5) != 0)) { + __pyx_t_8 = __pyx_t_6; } else { - __pyx_t_10 = __pyx_t_6; + __pyx_t_8 = __pyx_t_5; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "saliency_mbd.pyx":99 - * D[x][y] = b1 - * U[x][y] = max(u1,ix) - * L[x][y] = min(l1,ix) # <<<<<<<<<<<<<< + __pyx_t_4 = __pyx_v_x; + __pyx_t_3 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_U.diminfo[1].strides) = __pyx_t_8; + + /* "saliency_mbd.pyx":98 + * D[x,y] = b1 + * U[x,y] = max(u1,ix) + * L[x,y] = min(l1,ix) # <<<<<<<<<<<<<< * else: - * D[x][y] = b2 + * D[x,y] = b2 */ - __pyx_t_10 = __pyx_v_ix; - __pyx_t_8 = __pyx_v_l1; - if (((__pyx_t_10 < __pyx_t_8) != 0)) { - __pyx_t_6 = __pyx_t_10; + __pyx_t_8 = __pyx_v_ix; + __pyx_t_6 = __pyx_v_l1; + if (((__pyx_t_8 < __pyx_t_6) != 0)) { + __pyx_t_5 = __pyx_t_8; } else { - __pyx_t_6 = __pyx_t_8; + __pyx_t_5 = __pyx_t_6; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __pyx_v_x; + __pyx_t_4 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_L.diminfo[1].strides) = __pyx_t_5; - /* "saliency_mbd.pyx":96 + /* "saliency_mbd.pyx":95 * if d <= b1 and d <= b2: * continue * elif b1 < d and b1 <= b2: # <<<<<<<<<<<<<< - * D[x][y] = b1 - * U[x][y] = max(u1,ix) + * D[x,y] = b1 + * U[x,y] = max(u1,ix) */ goto __pyx_L7; } - /* "saliency_mbd.pyx":101 - * L[x][y] = min(l1,ix) + /* "saliency_mbd.pyx":100 + * L[x,y] = min(l1,ix) * else: - * D[x][y] = b2 # <<<<<<<<<<<<<< - * U[x][y] = max(u2,ix) - * L[x][y] = min(l2,ix) + * D[x,y] = b2 # <<<<<<<<<<<<<< + * U[x,y] = max(u2,ix) + * L[x,y] = min(l2,ix) */ /*else*/ { - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __pyx_v_x; + __pyx_t_3 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_D.diminfo[1].strides) = __pyx_v_b2; - /* "saliency_mbd.pyx":102 + /* "saliency_mbd.pyx":101 * else: - * D[x][y] = b2 - * U[x][y] = max(u2,ix) # <<<<<<<<<<<<<< - * L[x][y] = min(l2,ix) + * D[x,y] = b2 + * U[x,y] = max(u2,ix) # <<<<<<<<<<<<<< + * L[x,y] = min(l2,ix) * */ - __pyx_t_6 = __pyx_v_ix; - __pyx_t_10 = __pyx_v_u2; - if (((__pyx_t_6 > __pyx_t_10) != 0)) { - __pyx_t_8 = __pyx_t_6; + __pyx_t_5 = __pyx_v_ix; + __pyx_t_8 = __pyx_v_u2; + if (((__pyx_t_5 > __pyx_t_8) != 0)) { + __pyx_t_6 = __pyx_t_5; } else { - __pyx_t_8 = __pyx_t_10; + __pyx_t_6 = __pyx_t_8; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "saliency_mbd.pyx":103 - * D[x][y] = b2 - * U[x][y] = max(u2,ix) - * L[x][y] = min(l2,ix) # <<<<<<<<<<<<<< + __pyx_t_3 = __pyx_v_x; + __pyx_t_4 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_U.diminfo[1].strides) = __pyx_t_6; + + /* "saliency_mbd.pyx":102 + * D[x,y] = b2 + * U[x,y] = max(u2,ix) + * L[x,y] = min(l2,ix) # <<<<<<<<<<<<<< * * return True */ - __pyx_t_8 = __pyx_v_ix; - __pyx_t_6 = __pyx_v_l2; - if (((__pyx_t_8 < __pyx_t_6) != 0)) { - __pyx_t_10 = __pyx_t_8; + __pyx_t_6 = __pyx_v_ix; + __pyx_t_5 = __pyx_v_l2; + if (((__pyx_t_6 < __pyx_t_5) != 0)) { + __pyx_t_8 = __pyx_t_6; } else { - __pyx_t_10 = __pyx_t_6; + __pyx_t_8 = __pyx_t_5; } - __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __pyx_v_x; + __pyx_t_3 = __pyx_v_y; + *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_L.diminfo[1].strides) = __pyx_t_8; } __pyx_L7:; __pyx_L5_continue:; } } - /* "saliency_mbd.pyx":105 - * L[x][y] = min(l2,ix) + /* "saliency_mbd.pyx":104 + * L[x,y] = min(l2,ix) * * return True # <<<<<<<<<<<<<< * @@ -2845,8 +2832,8 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_i goto __pyx_L0; /* "saliency_mbd.pyx":61 - * * @cython.boundscheck(False) + * @cython.wraparound(False) * cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D): # <<<<<<<<<<<<<< * cdef int n_rows * cdef int n_cols @@ -2854,8 +2841,6 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_i /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -2880,18 +2865,24 @@ static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_i } /* "saliency_mbd.pyx":108 - * * @cython.boundscheck(False) + * @cython.wraparound(False) * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters): # <<<<<<<<<<<<<< * - * L = np.copy(img) + * cdef np.ndarray[double, ndim=2] L = np.copy(img) */ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __pyx_v_num_iters) { - PyObject *__pyx_v_L = NULL; - PyObject *__pyx_v_U = NULL; - PyObject *__pyx_v_D = NULL; + PyArrayObject *__pyx_v_L = 0; + PyArrayObject *__pyx_v_U = 0; + PyArrayObject *__pyx_v_D = 0; int __pyx_v_x; + __Pyx_LocalBuf_ND __pyx_pybuffernd_D; + __Pyx_Buffer __pyx_pybuffer_D; + __Pyx_LocalBuf_ND __pyx_pybuffernd_L; + __Pyx_Buffer __pyx_pybuffer_L; + __Pyx_LocalBuf_ND __pyx_pybuffernd_U; + __Pyx_Buffer __pyx_pybuffer_U; __Pyx_LocalBuf_ND __pyx_pybuffernd_img; __Pyx_Buffer __pyx_pybuffer_img; PyObject *__pyx_r = NULL; @@ -2899,31 +2890,46 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; + PyArrayObject *__pyx_t_4 = NULL; + PyArrayObject *__pyx_t_5 = NULL; int __pyx_t_6; - int __pyx_t_7; - int __pyx_t_8; + PyObject *__pyx_t_7 = NULL; + PyArrayObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("mbd", 0); - __pyx_pybuffer_img.pybuffer.buf = NULL; - __pyx_pybuffer_img.refcount = 0; - __pyx_pybuffernd_img.data = NULL; - __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img; - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 108, __pyx_L1_error) - } - __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1]; + __pyx_pybuffer_L.pybuffer.buf = NULL; + __pyx_pybuffer_L.refcount = 0; + __pyx_pybuffernd_L.data = NULL; + __pyx_pybuffernd_L.rcbuffer = &__pyx_pybuffer_L; + __pyx_pybuffer_U.pybuffer.buf = NULL; + __pyx_pybuffer_U.refcount = 0; + __pyx_pybuffernd_U.data = NULL; + __pyx_pybuffernd_U.rcbuffer = &__pyx_pybuffer_U; + __pyx_pybuffer_D.pybuffer.buf = NULL; + __pyx_pybuffer_D.refcount = 0; + __pyx_pybuffernd_D.data = NULL; + __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; + __pyx_pybuffer_img.pybuffer.buf = NULL; + __pyx_pybuffer_img.refcount = 0; + __pyx_pybuffernd_img.data = NULL; + __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 108, __pyx_L1_error) + } + __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1]; /* "saliency_mbd.pyx":110 * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters): * - * L = np.copy(img) # <<<<<<<<<<<<<< - * U = np.copy(img) - * D = np.full_like(img, 10000000) + * cdef np.ndarray[double, ndim=2] L = np.copy(img) # <<<<<<<<<<<<<< + * cdef np.ndarray[double, ndim=2] U = np.copy(img) + * cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -2945,14 +2951,25 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_L = __pyx_t_1; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 110, __pyx_L1_error) + __pyx_t_4 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_t_4, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + __pyx_v_L = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_L.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 110, __pyx_L1_error) + } else {__pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_t_4 = 0; + __pyx_v_L = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "saliency_mbd.pyx":111 * - * L = np.copy(img) - * U = np.copy(img) # <<<<<<<<<<<<<< - * D = np.full_like(img, 10000000) + * cdef np.ndarray[double, ndim=2] L = np.copy(img) + * cdef np.ndarray[double, ndim=2] U = np.copy(img) # <<<<<<<<<<<<<< + * cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000) * D[0,:] = 0 */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) @@ -2975,13 +2992,24 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_U = __pyx_t_1; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 111, __pyx_L1_error) + __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + __pyx_v_U = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_U.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 111, __pyx_L1_error) + } else {__pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_t_5 = 0; + __pyx_v_U = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "saliency_mbd.pyx":112 - * L = np.copy(img) - * U = np.copy(img) - * D = np.full_like(img, 10000000) # <<<<<<<<<<<<<< + * cdef np.ndarray[double, ndim=2] L = np.copy(img) + * cdef np.ndarray[double, ndim=2] U = np.copy(img) + * cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000) # <<<<<<<<<<<<<< * D[0,:] = 0 * D[-1,:] = 0 */ @@ -2991,7 +3019,7 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; - __pyx_t_4 = 0; + __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { @@ -2999,13 +3027,13 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_4 = 1; + __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_img), __pyx_int_10000000}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -3013,48 +3041,59 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_img), __pyx_int_10000000}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_2) { - __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_img)); __Pyx_GIVEREF(((PyObject *)__pyx_v_img)); - PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, ((PyObject *)__pyx_v_img)); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, ((PyObject *)__pyx_v_img)); __Pyx_INCREF(__pyx_int_10000000); __Pyx_GIVEREF(__pyx_int_10000000); - PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_int_10000000); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_10000000); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_D = __pyx_t_1; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_8 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + __pyx_v_D = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_D.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 112, __pyx_L1_error) + } else {__pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_t_8 = 0; + __pyx_v_D = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "saliency_mbd.pyx":113 - * U = np.copy(img) - * D = np.full_like(img, 10000000) + * cdef np.ndarray[double, ndim=2] U = np.copy(img) + * cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000) * D[0,:] = 0 # <<<<<<<<<<<<<< * D[-1,:] = 0 * D[:,0] = 0 */ - if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__2, __pyx_int_0) < 0)) __PYX_ERR(0, 113, __pyx_L1_error) + if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__2, __pyx_int_0) < 0)) __PYX_ERR(0, 113, __pyx_L1_error) /* "saliency_mbd.pyx":114 - * D = np.full_like(img, 10000000) + * cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000) * D[0,:] = 0 * D[-1,:] = 0 # <<<<<<<<<<<<<< * D[:,0] = 0 * D[:,-1] = 0 */ - if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__3, __pyx_int_0) < 0)) __PYX_ERR(0, 114, __pyx_L1_error) + if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__3, __pyx_int_0) < 0)) __PYX_ERR(0, 114, __pyx_L1_error) /* "saliency_mbd.pyx":115 * D[0,:] = 0 @@ -3063,7 +3102,7 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py * D[:,-1] = 0 * */ - if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__4, __pyx_int_0) < 0)) __PYX_ERR(0, 115, __pyx_L1_error) + if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__4, __pyx_int_0) < 0)) __PYX_ERR(0, 115, __pyx_L1_error) /* "saliency_mbd.pyx":116 * D[-1,:] = 0 @@ -3072,47 +3111,44 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py * * cdef int x */ - if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__5, __pyx_int_0) < 0)) __PYX_ERR(0, 116, __pyx_L1_error) + if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__5, __pyx_int_0) < 0)) __PYX_ERR(0, 116, __pyx_L1_error) /* "saliency_mbd.pyx":119 * * cdef int x - * for x in range(0,num_iters): # <<<<<<<<<<<<<< + * for x in xrange(0,num_iters): # <<<<<<<<<<<<<< * if x%2 == 1: * raster_scan(img,L,U,D) */ - __pyx_t_4 = __pyx_v_num_iters; - __pyx_t_6 = __pyx_t_4; - for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { - __pyx_v_x = __pyx_t_7; + __pyx_t_6 = __pyx_v_num_iters; + __pyx_t_9 = __pyx_t_6; + for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { + __pyx_v_x = __pyx_t_10; /* "saliency_mbd.pyx":120 * cdef int x - * for x in range(0,num_iters): + * for x in xrange(0,num_iters): * if x%2 == 1: # <<<<<<<<<<<<<< * raster_scan(img,L,U,D) * else: */ - __pyx_t_8 = ((__Pyx_mod_long(__pyx_v_x, 2) == 1) != 0); - if (__pyx_t_8) { + __pyx_t_11 = ((__Pyx_mod_long(__pyx_v_x, 2) == 1) != 0); + if (__pyx_t_11) { /* "saliency_mbd.pyx":121 - * for x in range(0,num_iters): + * for x in xrange(0,num_iters): * if x%2 == 1: * raster_scan(img,L,U,D) # <<<<<<<<<<<<<< * else: * raster_scan_inv(img,L,U,D) */ - if (!(likely(((__pyx_v_L) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_L, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error) - if (!(likely(((__pyx_v_U) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_U, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error) - if (!(likely(((__pyx_v_D) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_D, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error) __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "saliency_mbd.pyx":120 * cdef int x - * for x in range(0,num_iters): + * for x in xrange(0,num_iters): * if x%2 == 1: # <<<<<<<<<<<<<< * raster_scan(img,L,U,D) * else: @@ -3128,9 +3164,6 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py * return D */ /*else*/ { - if (!(likely(((__pyx_v_L) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_L, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error) - if (!(likely(((__pyx_v_U) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_U, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error) - if (!(likely(((__pyx_v_D) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_D, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error) __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan_inv(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -3143,19 +3176,19 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py * * return D # <<<<<<<<<<<<<< * - * def f(x): + * cdef f(x): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_D); - __pyx_r = __pyx_v_D; + __Pyx_INCREF(((PyObject *)__pyx_v_D)); + __pyx_r = ((PyObject *)__pyx_v_D); goto __pyx_L0; /* "saliency_mbd.pyx":108 - * * @cython.boundscheck(False) + * @cython.wraparound(False) * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters): # <<<<<<<<<<<<<< * - * L = np.copy(img) + * cdef np.ndarray[double, ndim=2] L = np.copy(img) */ /* function exit code */ @@ -3163,22 +3196,28 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("saliency_mbd.mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; goto __pyx_L2; __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer); __pyx_L2:; - __Pyx_XDECREF(__pyx_v_L); - __Pyx_XDECREF(__pyx_v_U); - __Pyx_XDECREF(__pyx_v_D); + __Pyx_XDECREF((PyObject *)__pyx_v_L); + __Pyx_XDECREF((PyObject *)__pyx_v_U); + __Pyx_XDECREF((PyObject *)__pyx_v_D); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; @@ -3187,26 +3226,12 @@ static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __py /* "saliency_mbd.pyx":127 * return D * - * def f(x): # <<<<<<<<<<<<<< + * cdef f(x): # <<<<<<<<<<<<<< * b = 10.0 * return 1.0 / (1.0 + exp(-b*(x - 0.5))) */ -/* Python wrapper */ -static PyObject *__pyx_pw_12saliency_mbd_1f(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ -static PyMethodDef __pyx_mdef_12saliency_mbd_1f = {"f", (PyCFunction)__pyx_pw_12saliency_mbd_1f, METH_O, 0}; -static PyObject *__pyx_pw_12saliency_mbd_1f(PyObject *__pyx_self, PyObject *__pyx_v_x) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("f (wrapper)", 0); - __pyx_r = __pyx_pf_12saliency_mbd_f(__pyx_self, ((PyObject *)__pyx_v_x)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { +static PyObject *__pyx_f_12saliency_mbd_f(PyObject *__pyx_v_x) { double __pyx_v_b; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations @@ -3222,7 +3247,7 @@ static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, P /* "saliency_mbd.pyx":128 * - * def f(x): + * cdef f(x): * b = 10.0 # <<<<<<<<<<<<<< * return 1.0 / (1.0 + exp(-b*(x - 0.5))) * @@ -3230,7 +3255,7 @@ static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, P __pyx_v_b = 10.0; /* "saliency_mbd.pyx":129 - * def f(x): + * cdef f(x): * b = 10.0 * return 1.0 / (1.0 + exp(-b*(x - 0.5))) # <<<<<<<<<<<<<< * @@ -3261,7 +3286,7 @@ static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, P /* "saliency_mbd.pyx":127 * return D * - * def f(x): # <<<<<<<<<<<<<< + * cdef f(x): # <<<<<<<<<<<<<< * b = 10.0 * return 1.0 / (1.0 + exp(-b*(x - 0.5))) */ @@ -3272,31 +3297,84 @@ static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, P __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("saliency_mbd.f", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "saliency_mbd.pyx":132 - * +/* "saliency_mbd.pyx":133 * @cython.boundscheck(False) + * @cython.wraparound(False) * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS * img_mean = np.mean(img,axis=(2)) */ -static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_12saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_img, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd *__pyx_optional_args) { PyObject *__pyx_v_img_mean = NULL; PyObject *__pyx_v_sal = NULL; + int __pyx_v_n_rows; + int __pyx_v_n_cols; + CYTHON_UNUSED int __pyx_v_n_channels; + double __pyx_v_img_size; + PyObject *__pyx_v_border_thickness = NULL; + PyArrayObject *__pyx_v_img_lab = 0; + PyObject *__pyx_v_px_left = NULL; + PyObject *__pyx_v_px_right = NULL; + PyObject *__pyx_v_px_top = NULL; + PyObject *__pyx_v_px_bottom = NULL; + PyObject *__pyx_v_px_mean_left = NULL; + PyObject *__pyx_v_px_mean_right = NULL; + PyObject *__pyx_v_px_mean_top = NULL; + PyObject *__pyx_v_px_mean_bottom = NULL; + PyObject *__pyx_v_cov_left = NULL; + PyObject *__pyx_v_cov_right = NULL; + PyObject *__pyx_v_cov_top = NULL; + PyObject *__pyx_v_cov_bottom = NULL; + PyObject *__pyx_v_u_left = NULL; + PyObject *__pyx_v_u_right = NULL; + PyObject *__pyx_v_u_top = NULL; + PyObject *__pyx_v_u_bottom = NULL; + PyObject *__pyx_v_u_final = NULL; + PyObject *__pyx_v_img_lab_unrolled = NULL; + PyObject *__pyx_v_px_mean_left_2 = NULL; + PyObject *__pyx_v_px_mean_right_2 = NULL; + PyObject *__pyx_v_px_mean_top_2 = NULL; + PyObject *__pyx_v_px_mean_bottom_2 = NULL; + PyObject *__pyx_v_max_u_left = NULL; + PyObject *__pyx_v_max_u_right = NULL; + PyObject *__pyx_v_max_u_top = NULL; + PyObject *__pyx_v_max_u_bottom = NULL; + PyObject *__pyx_v_u_max = NULL; + PyObject *__pyx_v_u_max_final = NULL; + PyObject *__pyx_v_sal_max = NULL; + PyObject *__pyx_v_s = NULL; + double __pyx_v_alpha; + CYTHON_UNUSED double __pyx_v_delta; + PyObject *__pyx_v_xv = NULL; + PyObject *__pyx_v_yv = NULL; + int __pyx_v_w; + int __pyx_v_h; + double __pyx_v_w2; + double __pyx_v_h2; + PyObject *__pyx_v_C = NULL; + PyObject *__pyx_v_fv = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + double __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -3304,27 +3382,27 @@ static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_ if (__pyx_optional_args) { } - /* "saliency_mbd.pyx":134 + /* "saliency_mbd.pyx":135 * cpdef get_saliency_mbd(np.ndarray img,method='b'): * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS * img_mean = np.mean(img,axis=(2)) # <<<<<<<<<<<<<< * sal = mbd(img_mean,2) * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)__pyx_v_img)); __Pyx_GIVEREF(((PyObject *)__pyx_v_img)); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_img)); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_int_2) < 0) __PYX_ERR(0, 134, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_int_2) < 0) __PYX_ERR(0, 135, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -3332,2489 +3410,3224 @@ static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_ __pyx_v_img_mean = __pyx_t_4; __pyx_t_4 = 0; - /* "saliency_mbd.pyx":135 + /* "saliency_mbd.pyx":136 * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS * img_mean = np.mean(img,axis=(2)) * sal = mbd(img_mean,2) # <<<<<<<<<<<<<< * - * #cdef int n_rows = img.shape[0] + * cdef int n_rows = img.shape[0] */ - if (!(likely(((__pyx_v_img_mean) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_img_mean, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 135, __pyx_L1_error) - __pyx_t_4 = __pyx_f_12saliency_mbd_mbd(((PyArrayObject *)__pyx_v_img_mean), 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error) + if (!(likely(((__pyx_v_img_mean) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_img_mean, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 136, __pyx_L1_error) + __pyx_t_4 = __pyx_f_12saliency_mbd_mbd(((PyArrayObject *)__pyx_v_img_mean), 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_sal = __pyx_t_4; __pyx_t_4 = 0; - /* "saliency_mbd.pyx":250 - * #sal = fv(sal) + /* "saliency_mbd.pyx":138 + * sal = mbd(img_mean,2) * - * return sal* 255.0 # <<<<<<<<<<<<<< + * cdef int n_rows = img.shape[0] # <<<<<<<<<<<<<< + * cdef int n_cols = img.shape[1] + * cdef int n_channels = img.shape[2] */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; + __pyx_v_n_rows = (__pyx_v_img->dimensions[0]); - /* "saliency_mbd.pyx":132 + /* "saliency_mbd.pyx":139 * - * @cython.boundscheck(False) - * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< - * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS - * img_mean = np.mean(img,axis=(2)) + * cdef int n_rows = img.shape[0] + * cdef int n_cols = img.shape[1] # <<<<<<<<<<<<<< + * cdef int n_channels = img.shape[2] + * cdef double img_size = sqrt(n_rows * n_cols) */ + __pyx_v_n_cols = (__pyx_v_img->dimensions[1]); - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_img_mean); - __Pyx_XDECREF(__pyx_v_sal); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* Python wrapper */ -static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyArrayObject *__pyx_v_img = 0; - PyObject *__pyx_v_method = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("get_saliency_mbd (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_img,&__pyx_n_s_method,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)__pyx_n_s_b); - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_img)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method); - if (value) { values[1] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 132, __pyx_L3_error) - } - } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_img = ((PyArrayObject *)values[0]); - __pyx_v_method = values[1]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 132, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 132, __pyx_L1_error) - __pyx_r = __pyx_pf_12saliency_mbd_2get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_saliency_mbd", 0); - __Pyx_XDECREF(__pyx_r); - __pyx_t_2.__pyx_n = 1; - __pyx_t_2.method = __pyx_v_method; - __pyx_t_1 = __pyx_f_12saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 - * # experimental exception made for __getbuffer__ and __releasebuffer__ - * # -- the details of this may change. - * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< - * # This implementation of getbuffer is geared towards Cython - * # requirements, and does not yet fulfill the PEP. + /* "saliency_mbd.pyx":140 + * cdef int n_rows = img.shape[0] + * cdef int n_cols = img.shape[1] + * cdef int n_channels = img.shape[2] # <<<<<<<<<<<<<< + * cdef double img_size = sqrt(n_rows * n_cols) + * border_thickness = int(floor(0.1 * img_size)) */ + __pyx_v_n_channels = (__pyx_v_img->dimensions[2]); -/* Python wrapper */ -static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_v_i; - int __pyx_v_ndim; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - int __pyx_v_t; - char *__pyx_v_f; - PyArray_Descr *__pyx_v_descr = 0; - int __pyx_v_offset; - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - PyArray_Descr *__pyx_t_7; - PyObject *__pyx_t_8 = NULL; - char *__pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - if (__pyx_v_info == NULL) { - PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); - return -1; - } - __Pyx_RefNannySetupContext("__getbuffer__", 0); - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 - * - * cdef int i, ndim - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) + /* "saliency_mbd.pyx":141 + * cdef int n_cols = img.shape[1] + * cdef int n_channels = img.shape[2] + * cdef double img_size = sqrt(n_rows * n_cols) # <<<<<<<<<<<<<< + * border_thickness = int(floor(0.1 * img_size)) * */ - __pyx_v_endian_detector = 1; + __pyx_v_img_size = sqrt((__pyx_v_n_rows * __pyx_v_n_cols)); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 - * cdef int i, ndim - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":142 + * cdef int n_channels = img.shape[2] + * cdef double img_size = sqrt(n_rows * n_cols) + * border_thickness = int(floor(0.1 * img_size)) # <<<<<<<<<<<<<< * - * ndim = PyArray_NDIM(self) + * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + __pyx_t_4 = __Pyx_PyInt_FromDouble(floor((0.1 * __pyx_v_img_size))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_border_thickness = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * - * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":144 + * border_thickness = int(floor(0.1 * img_size)) * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - */ - __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) + * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) # <<<<<<<<<<<<<< * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") + * px_left = img_lab[0:border_thickness,:,:] */ - __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_skimage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_color); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_rgb2lab); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_img)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_v_img_lab = ((PyArrayObject *)__pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + /* "saliency_mbd.pyx":146 + * cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img)) * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< - * raise ValueError(u"ndarray is not C contiguous") + * px_left = img_lab[0:border_thickness,:,:] # <<<<<<<<<<<<<< + * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] * */ - __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; + __pyx_t_4 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_slice_); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_px_left = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) + /* "saliency_mbd.pyx":147 * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") - */ - if (unlikely(__pyx_t_1)) { - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * px_left = img_lab[0:border_thickness,:,:] + * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] # <<<<<<<<<<<<<< * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * px_top = img_lab[:,0:border_thickness,:] */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 272, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_v_border_thickness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PySlice_New(__pyx_t_4, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_slice_); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_px_right = __pyx_t_3; + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) + /* "saliency_mbd.pyx":149 + * px_right = img_lab[n_rows - border_thickness-1:-1,:,:] * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") - */ - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") + * px_top = img_lab[:,0:border_thickness,:] # <<<<<<<<<<<<<< + * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") */ - __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L7_bool_binop_done; - } + __pyx_t_3 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_slice_); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_px_top = __pyx_t_3; + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + /* "saliency_mbd.pyx":150 * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< - * raise ValueError(u"ndarray is not Fortran contiguous") + * px_top = img_lab[:,0:border_thickness,:] + * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] # <<<<<<<<<<<<<< * + * px_mean_left = np.mean(px_left,axis=(0,1)) */ - __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L7_bool_binop_done:; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_v_border_thickness); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PySlice_New(__pyx_t_3, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_slice_); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_px_bottom = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") + /* "saliency_mbd.pyx":152 + * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") + * px_mean_left = np.mean(px_left,axis=(0,1)) # <<<<<<<<<<<<<< + * px_mean_right = np.mean(px_right,axis=(0,1)) + * px_mean_top = np.mean(px_top,axis=(0,1)) */ - if (unlikely(__pyx_t_1)) { + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_px_left); + __Pyx_GIVEREF(__pyx_v_px_left); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_px_left); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 152, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_px_mean_left = __pyx_t_2; + __pyx_t_2 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":153 * - * info.buf = PyArray_DATA(self) + * px_mean_left = np.mean(px_left,axis=(0,1)) + * px_mean_right = np.mean(px_right,axis=(0,1)) # <<<<<<<<<<<<<< + * px_mean_top = np.mean(px_top,axis=(0,1)) + * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_px_right); + __Pyx_GIVEREF(__pyx_v_px_right); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_px_right); + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 153, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_px_mean_right = __pyx_t_3; + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") + /* "saliency_mbd.pyx":154 + * px_mean_left = np.mean(px_left,axis=(0,1)) + * px_mean_right = np.mean(px_right,axis=(0,1)) + * px_mean_top = np.mean(px_top,axis=(0,1)) # <<<<<<<<<<<<<< + * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") */ - } + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_px_top); + __Pyx_GIVEREF(__pyx_v_px_top); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_px_top); + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_px_mean_top = __pyx_t_1; + __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 - * raise ValueError(u"ndarray is not Fortran contiguous") + /* "saliency_mbd.pyx":155 + * px_mean_right = np.mean(px_right,axis=(0,1)) + * px_mean_top = np.mean(px_top,axis=(0,1)) + * px_mean_bottom = np.mean(px_bottom,axis=(0,1)) # <<<<<<<<<<<<<< * - * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - */ - __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * - * info.buf = PyArray_DATA(self) - * info.ndim = ndim # <<<<<<<<<<<<<< - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * # Allocate new buffer for strides and shape info. - */ - __pyx_v_info->ndim = __pyx_v_ndim; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 - * info.buf = PyArray_DATA(self) - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - */ - __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); - if (__pyx_t_1) { - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< - * info.shape = info.strides + ndim - * for i in range(ndim): - */ - __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 - * # This is allocated as one block, strides first. - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) - * info.shape = info.strides + ndim # <<<<<<<<<<<<<< - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] - */ - __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) - * info.shape = info.strides + ndim - * for i in range(ndim): # <<<<<<<<<<<<<< - * info.strides[i] = PyArray_STRIDES(self)[i] - * info.shape[i] = PyArray_DIMS(self)[i] - */ - __pyx_t_4 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_4; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 - * info.shape = info.strides + ndim - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< - * info.shape[i] = PyArray_DIMS(self)[i] - * else: */ - (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_px_bottom); + __Pyx_GIVEREF(__pyx_v_px_bottom); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_px_bottom); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_px_mean_bottom = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] - * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< - * else: - * info.strides = PyArray_STRIDES(self) + /* "saliency_mbd.pyx":158 + * + * + * px_left = px_left.reshape((n_cols*border_thickness,3)) # <<<<<<<<<<<<<< + * px_right = px_right.reshape((n_cols*border_thickness,3)) + * */ - (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 - * info.buf = PyArray_DATA(self) - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - */ - goto __pyx_L9; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 - * info.shape[i] = PyArray_DIMS(self)[i] - * else: - * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL - */ - /*else*/ { - __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 - * else: - * info.strides = PyArray_STRIDES(self) - * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) - */ - __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } - __pyx_L9:; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 - * info.strides = PyArray_STRIDES(self) - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = PyArray_ITEMSIZE(self) - * info.readonly = not PyArray_ISWRITEABLE(self) - */ - __pyx_v_info->suboffsets = NULL; + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_px_left, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< - * info.readonly = not PyArray_ISWRITEABLE(self) + /* "saliency_mbd.pyx":159 * - */ - __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) - * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * px_left = px_left.reshape((n_cols*border_thickness,3)) + * px_right = px_right.reshape((n_cols*border_thickness,3)) # <<<<<<<<<<<<<< * - * cdef int t + * px_top = px_top.reshape((n_rows*border_thickness,3)) */ - __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_px_right, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 + /* "saliency_mbd.pyx":161 + * px_right = px_right.reshape((n_cols*border_thickness,3)) * - * cdef int t - * cdef char* f = NULL # <<<<<<<<<<<<<< - * cdef dtype descr = PyArray_DESCR(self) - * cdef int offset - */ - __pyx_v_f = NULL; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 - * cdef int t - * cdef char* f = NULL - * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< - * cdef int offset + * px_top = px_top.reshape((n_rows*border_thickness,3)) # <<<<<<<<<<<<<< + * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) * */ - __pyx_t_7 = PyArray_DESCR(__pyx_v_self); - __pyx_t_3 = ((PyObject *)__pyx_t_7); - __Pyx_INCREF(__pyx_t_3); - __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_px_top, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 - * cdef int offset + /* "saliency_mbd.pyx":162 * - * info.obj = self # <<<<<<<<<<<<<< + * px_top = px_top.reshape((n_rows*border_thickness,3)) + * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) # <<<<<<<<<<<<<< * - * if not PyDataType_HASFIELDS(descr): + * cov_left = np.cov(px_left.T) */ - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3); + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_px_bottom, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 - * info.obj = self + /* "saliency_mbd.pyx":164 + * px_bottom = px_bottom.reshape((n_rows*border_thickness,3)) * - * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or - */ - __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); - if (__pyx_t_1) { - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 + * cov_left = np.cov(px_left.T) # <<<<<<<<<<<<<< + * cov_right = np.cov(px_right.T) * - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num # <<<<<<<<<<<<<< - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - */ - __pyx_t_4 = __pyx_v_descr->type_num; - __pyx_v_t = __pyx_t_4; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") */ - __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); - if (!__pyx_t_2) { - goto __pyx_L15_next_or; - } else { - } - __pyx_t_2 = (__pyx_v_little_endian != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L14_bool_binop_done; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); } - __pyx_L15_next_or:; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" - */ - __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L14_bool_binop_done; - } - __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L14_bool_binop_done:; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - if (unlikely(__pyx_t_1)) { - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 306, __pyx_L1_error) - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" - */ - switch (__pyx_v_t) { - case NPY_BYTE: - __pyx_v_f = ((char *)"b"); - break; - case NPY_UBYTE: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" - */ - __pyx_v_f = ((char *)"B"); - break; - case NPY_SHORT: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" - */ - __pyx_v_f = ((char *)"h"); - break; - case NPY_USHORT: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" - */ - __pyx_v_f = ((char *)"H"); - break; - case NPY_INT: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" - */ - __pyx_v_f = ((char *)"i"); - break; - case NPY_UINT: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" - */ - __pyx_v_f = ((char *)"I"); - break; - case NPY_LONG: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" - */ - __pyx_v_f = ((char *)"l"); - break; - case NPY_ULONG: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" - */ - __pyx_v_f = ((char *)"L"); - break; - case NPY_LONGLONG: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" - */ - __pyx_v_f = ((char *)"q"); - break; - case NPY_ULONGLONG: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" - */ - __pyx_v_f = ((char *)"Q"); - break; - case NPY_FLOAT: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" - */ - __pyx_v_f = ((char *)"f"); - break; - case NPY_DOUBLE: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" - */ - __pyx_v_f = ((char *)"d"); - break; - case NPY_LONGDOUBLE: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" - */ - __pyx_v_f = ((char *)"g"); - break; - case NPY_CFLOAT: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" - */ - __pyx_v_f = ((char *)"Zf"); - break; - case NPY_CDOUBLE: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" - */ - __pyx_v_f = ((char *)"Zd"); - break; - case NPY_CLONGDOUBLE: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f = "O" - * else: - */ - __pyx_v_f = ((char *)"Zg"); - break; - case NPY_OBJECT: - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - */ - __pyx_v_f = ((char *)"O"); - break; - default: + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_cov_left = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 - * elif t == NPY_OBJECT: f = "O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * info.format = f - * return + /* "saliency_mbd.pyx":165 + * + * cov_left = np.cov(px_left.T) + * cov_right = np.cov(px_right.T) # <<<<<<<<<<<<<< + * + * cov_top = np.cov(px_top.T) */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 325, __pyx_L1_error) - break; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cov_right = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * info.format = f # <<<<<<<<<<<<<< - * return - * else: - */ - __pyx_v_info->format = __pyx_v_f; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * info.format = f - * return # <<<<<<<<<<<<<< - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 - * info.obj = self + /* "saliency_mbd.pyx":167 + * cov_right = np.cov(px_right.T) + * + * cov_top = np.cov(px_top.T) # <<<<<<<<<<<<<< + * cov_bottom = np.cov(px_bottom.T) * - * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_cov_top = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 - * return - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 - */ - /*else*/ { - __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) - * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< - * offset = 0 - * f = _util_dtypestring(descr, info.format + 1, + /* "saliency_mbd.pyx":168 + * + * cov_top = np.cov(px_top.T) + * cov_bottom = np.cov(px_bottom.T) # <<<<<<<<<<<<<< + * + * cov_left = np.linalg.inv(cov_left) */ - (__pyx_v_info->format[0]) = '^'; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 - * info.format = PyObject_Malloc(_buffer_format_string_len) - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 # <<<<<<<<<<<<<< - * f = _util_dtypestring(descr, info.format + 1, - * info.format + _buffer_format_string_len, - */ - __pyx_v_offset = 0; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 - * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< - * info.format + _buffer_format_string_len, - * &offset) - */ - __pyx_t_9 = __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_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) - __pyx_v_f = __pyx_t_9; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cov_bottom = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 - * info.format + _buffer_format_string_len, - * &offset) - * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":170 + * cov_bottom = np.cov(px_bottom.T) + * + * cov_left = np.linalg.inv(cov_left) # <<<<<<<<<<<<<< + * cov_right = np.linalg.inv(cov_right) * - * def __releasebuffer__(ndarray self, Py_buffer* info): */ - (__pyx_v_f[0]) = '\x00'; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_left) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_left); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_cov_left, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 - * # experimental exception made for __getbuffer__ and __releasebuffer__ - * # -- the details of this may change. - * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< - * # This implementation of getbuffer is geared towards Cython - * # requirements, and does not yet fulfill the PEP. + /* "saliency_mbd.pyx":171 + * + * cov_left = np.linalg.inv(cov_left) + * cov_right = np.linalg.inv(cov_right) # <<<<<<<<<<<<<< + * + * cov_top = np.linalg.inv(cov_top) */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - goto __pyx_L2; - __pyx_L0:; - if (__pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } } - __pyx_L2:; - __Pyx_XDECREF((PyObject *)__pyx_v_descr); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_right) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_right); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_cov_right, __pyx_t_4); + __pyx_t_4 = 0; -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 - * f[0] = c'\0' # Terminate format string + /* "saliency_mbd.pyx":173 + * cov_right = np.linalg.inv(cov_right) * - * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) - */ - -/* Python wrapper */ -static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ -static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); - __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__releasebuffer__", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 + * cov_top = np.linalg.inv(cov_top) # <<<<<<<<<<<<<< + * cov_bottom = np.linalg.inv(cov_bottom) * - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ - __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); - if (__pyx_t_1) { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_top) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_top); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_cov_top, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) # <<<<<<<<<<<<<< - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * PyObject_Free(info.strides) + /* "saliency_mbd.pyx":174 + * + * cov_top = np.linalg.inv(cov_top) + * cov_bottom = np.linalg.inv(cov_bottom) # <<<<<<<<<<<<<< + * + * */ - PyObject_Free(__pyx_v_info->format); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_bottom); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_cov_bottom, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 + /* "saliency_mbd.pyx":177 + * * - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * u_left = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * u_right = np.zeros(sal.shape) + * u_top = np.zeros(sal.shape) */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_u_left = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * PyObject_Free(info.strides) - * # info.shape was stored after info.strides in the same block + /* "saliency_mbd.pyx":178 + * + * u_left = np.zeros(sal.shape) + * u_right = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * u_top = np.zeros(sal.shape) + * u_bottom = np.zeros(sal.shape) */ - __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); - if (__pyx_t_1) { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_u_right = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * PyObject_Free(info.strides) # <<<<<<<<<<<<<< - * # info.shape was stored after info.strides in the same block + /* "saliency_mbd.pyx":179 + * u_left = np.zeros(sal.shape) + * u_right = np.zeros(sal.shape) + * u_top = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * u_bottom = np.zeros(sal.shape) * */ - PyObject_Free(__pyx_v_info->strides); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_u_top = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * PyObject_Free(info.strides) - * # info.shape was stored after info.strides in the same block + /* "saliency_mbd.pyx":180 + * u_right = np.zeros(sal.shape) + * u_top = np.zeros(sal.shape) + * u_bottom = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * + * u_final = np.zeros(sal.shape) */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_u_bottom = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 - * f[0] = c'\0' # Terminate format string + /* "saliency_mbd.pyx":182 + * u_bottom = np.zeros(sal.shape) + * + * u_final = np.zeros(sal.shape) # <<<<<<<<<<<<<< + * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) * - * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_u_final = __pyx_t_4; + __pyx_t_4 = 0; - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 - * ctypedef npy_cdouble complex_t + /* "saliency_mbd.pyx":183 * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) + * u_final = np.zeros(sal.shape) + * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) # <<<<<<<<<<<<<< * + * px_mean_left_2 = np.zeros((1,3)) */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_img_lab), __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(((__pyx_v_img_lab->dimensions[0]) * (__pyx_v_img_lab->dimensions[1]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_t_3); + __Pyx_INCREF(__pyx_int_3); + __Pyx_GIVEREF(__pyx_int_3); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_int_3); + __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_img_lab_unrolled = __pyx_t_4; + __pyx_t_4 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + /* "saliency_mbd.pyx":185 + * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) * - * cdef inline object PyArray_MultiIterNew1(a): - * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * px_mean_left_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_left_2[0,:] = px_mean_left * - * cdef inline object PyArray_MultiIterNew2(a, b): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 821, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 185, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_tuple__7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_px_mean_left_2 = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 - * ctypedef npy_cdouble complex_t + /* "saliency_mbd.pyx":186 * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) + * px_mean_left_2 = np.zeros((1,3)) + * px_mean_left_2[0,:] = px_mean_left # <<<<<<<<<<<<<< * + * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) */ + if (unlikely(PyObject_SetItem(__pyx_v_px_mean_left_2, __pyx_tuple__2, __pyx_v_px_mean_left) < 0)) __PYX_ERR(0, 186, __pyx_L1_error) - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 - * return PyArray_MultiIterNew(1, a) + /* "saliency_mbd.pyx":188 + * px_mean_left_2[0,:] = px_mean_left * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) + * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) # <<<<<<<<<<<<<< + * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) * */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_scipy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_spatial); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_distance); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_cdist); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_img_lab_unrolled); + __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_img_lab_unrolled); + __Pyx_INCREF(__pyx_v_px_mean_left_2); + __Pyx_GIVEREF(__pyx_v_px_mean_left_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_px_mean_left_2); + __Pyx_INCREF(__pyx_n_s_mahalanobis); + __Pyx_GIVEREF(__pyx_n_s_mahalanobis); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_n_s_mahalanobis); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_left) < 0) __PYX_ERR(0, 188, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3); + __pyx_t_3 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 + /* "saliency_mbd.pyx":189 * - * cdef inline object PyArray_MultiIterNew2(a, b): - * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left) + * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew3(a, b, c): + * px_mean_right_2 = np.zeros((1,3)) */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 824, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_5); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 - * return PyArray_MultiIterNew(1, a) + /* "saliency_mbd.pyx":191 + * u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1])) * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) + * px_mean_right_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_right_2[0,:] = px_mean_right * */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_tuple__7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_px_mean_right_2 = __pyx_t_3; + __pyx_t_3 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 - * return PyArray_MultiIterNew(2, a, b) + /* "saliency_mbd.pyx":192 * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) + * px_mean_right_2 = np.zeros((1,3)) + * px_mean_right_2[0,:] = px_mean_right # <<<<<<<<<<<<<< * + * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) */ + if (unlikely(PyObject_SetItem(__pyx_v_px_mean_right_2, __pyx_tuple__2, __pyx_v_px_mean_right) < 0)) __PYX_ERR(0, 192, __pyx_L1_error) -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + /* "saliency_mbd.pyx":194 + * px_mean_right_2[0,:] = px_mean_right * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) # <<<<<<<<<<<<<< + * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_scipy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_spatial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_distance); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cdist); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_img_lab_unrolled); + __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_img_lab_unrolled); + __Pyx_INCREF(__pyx_v_px_mean_right_2); + __Pyx_GIVEREF(__pyx_v_px_mean_right_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_px_mean_right_2); + __Pyx_INCREF(__pyx_n_s_mahalanobis); + __Pyx_GIVEREF(__pyx_n_s_mahalanobis); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_n_s_mahalanobis); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_right) < 0) __PYX_ERR(0, 194, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5); + __pyx_t_5 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 - * return PyArray_MultiIterNew(2, a, b) + /* "saliency_mbd.pyx":195 * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) + * u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right) + * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< * + * px_mean_top_2 = np.zeros((1,3)) */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __pyx_t_3 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5); + __pyx_t_5 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 - * return PyArray_MultiIterNew(3, a, b, c) + /* "saliency_mbd.pyx":197 + * u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1])) * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) + * px_mean_top_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_top_2[0,:] = px_mean_top * */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_tuple__7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_px_mean_top_2 = __pyx_t_5; + __pyx_t_5 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + /* "saliency_mbd.pyx":198 * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): - * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * px_mean_top_2 = np.zeros((1,3)) + * px_mean_top_2[0,:] = px_mean_top # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 830, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + if (unlikely(PyObject_SetItem(__pyx_v_px_mean_top_2, __pyx_tuple__2, __pyx_v_px_mean_top) < 0)) __PYX_ERR(0, 198, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 - * return PyArray_MultiIterNew(3, a, b, c) + /* "saliency_mbd.pyx":200 + * px_mean_top_2[0,:] = px_mean_top * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) + * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) # <<<<<<<<<<<<<< + * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) * */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_scipy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_spatial); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_distance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_cdist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_img_lab_unrolled); + __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_img_lab_unrolled); + __Pyx_INCREF(__pyx_v_px_mean_top_2); + __Pyx_GIVEREF(__pyx_v_px_mean_top_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_px_mean_top_2); + __Pyx_INCREF(__pyx_n_s_mahalanobis); + __Pyx_GIVEREF(__pyx_n_s_mahalanobis); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_n_s_mahalanobis); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_top) < 0) __PYX_ERR(0, 200, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2); + __pyx_t_2 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 - * return PyArray_MultiIterNew(4, a, b, c, d) + /* "saliency_mbd.pyx":201 * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) + * u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top) + * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< * + * px_mean_bottom_2 = np.zeros((1,3)) */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); + __pyx_t_5 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2); + __pyx_t_2 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + /* "saliency_mbd.pyx":203 + * u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1])) * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * px_mean_bottom_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_bottom_2[0,:] = px_mean_bottom * - * cdef inline tuple PyDataType_SHAPE(dtype d): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 833, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_tuple__7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_px_mean_bottom_2 = __pyx_t_2; + __pyx_t_2 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 - * return PyArray_MultiIterNew(4, a, b, c, d) + /* "saliency_mbd.pyx":204 * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) + * px_mean_bottom_2 = np.zeros((1,3)) + * px_mean_bottom_2[0,:] = px_mean_bottom # <<<<<<<<<<<<<< * + * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) */ + if (unlikely(PyObject_SetItem(__pyx_v_px_mean_bottom_2, __pyx_tuple__2, __pyx_v_px_mean_bottom) < 0)) __PYX_ERR(0, 204, __pyx_L1_error) - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 - * return PyArray_MultiIterNew(5, a, b, c, d, e) + /* "saliency_mbd.pyx":206 + * px_mean_bottom_2[0,:] = px_mean_bottom + * + * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) # <<<<<<<<<<<<<< + * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_scipy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_spatial); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_distance); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_cdist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_img_lab_unrolled); + __Pyx_GIVEREF(__pyx_v_img_lab_unrolled); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_img_lab_unrolled); + __Pyx_INCREF(__pyx_v_px_mean_bottom_2); + __Pyx_GIVEREF(__pyx_v_px_mean_bottom_2); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_px_mean_bottom_2); + __Pyx_INCREF(__pyx_n_s_mahalanobis); + __Pyx_GIVEREF(__pyx_n_s_mahalanobis); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_mahalanobis); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_bottom) < 0) __PYX_ERR(0, 206, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); + __pyx_t_4 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + /* "saliency_mbd.pyx":207 * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: + * u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom) + * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) # <<<<<<<<<<<<<< + * + * max_u_left = np.max(u_left) */ - __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); - if (__pyx_t_1) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape # <<<<<<<<<<<<<< - * else: - * return () + /* "saliency_mbd.pyx":209 + * u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1])) + * + * max_u_left = np.max(u_left) # <<<<<<<<<<<<<< + * max_u_right = np.max(u_right) + * max_u_top = np.max(u_top) */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); - __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); - goto __pyx_L0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_left) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_left); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_max_u_left = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + /* "saliency_mbd.pyx":210 * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: + * max_u_left = np.max(u_left) + * max_u_right = np.max(u_right) # <<<<<<<<<<<<<< + * max_u_top = np.max(u_top) + * max_u_bottom = np.max(u_bottom) */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_right) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_right); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_max_u_right = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 - * return d.subarray.shape - * else: - * return () # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":211 + * max_u_left = np.max(u_left) + * max_u_right = np.max(u_right) + * max_u_top = np.max(u_top) # <<<<<<<<<<<<<< + * max_u_bottom = np.max(u_bottom) * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_r = __pyx_empty_tuple; - goto __pyx_L0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_top) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_top); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_max_u_top = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 - * return PyArray_MultiIterNew(5, a, b, c, d, e) + /* "saliency_mbd.pyx":212 + * max_u_right = np.max(u_right) + * max_u_top = np.max(u_top) + * max_u_bottom = np.max(u_bottom) # <<<<<<<<<<<<<< * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape + * u_left = u_left / max_u_left */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_bottom); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_max_u_bottom = __pyx_t_4; + __pyx_t_4 = 0; - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 - * return () + /* "saliency_mbd.pyx":214 + * max_u_bottom = np.max(u_bottom) * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. + * u_left = u_left / max_u_left # <<<<<<<<<<<<<< + * u_right = u_right / max_u_right + * u_top = u_top / max_u_top */ + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_left, __pyx_v_max_u_left); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_4); + __pyx_t_4 = 0; -static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { - PyArray_Descr *__pyx_v_child = 0; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - PyObject *__pyx_v_fields = 0; - PyObject *__pyx_v_childname = NULL; - PyObject *__pyx_v_new_offset = NULL; - PyObject *__pyx_v_t = NULL; - char *__pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_t_7; - long __pyx_t_8; - char *__pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_util_dtypestring", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":846 + /* "saliency_mbd.pyx":215 * - * cdef dtype child - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * cdef tuple fields + * u_left = u_left / max_u_left + * u_right = u_right / max_u_right # <<<<<<<<<<<<<< + * u_top = u_top / max_u_top + * u_bottom = u_bottom / max_u_bottom */ - __pyx_v_endian_detector = 1; + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_right, __pyx_v_max_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 - * cdef dtype child - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< - * cdef tuple fields + /* "saliency_mbd.pyx":216 + * u_left = u_left / max_u_left + * u_right = u_right / max_u_right + * u_top = u_top / max_u_top # <<<<<<<<<<<<<< + * u_bottom = u_bottom / max_u_bottom * */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_top, __pyx_v_max_u_top); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 - * cdef tuple fields + /* "saliency_mbd.pyx":217 + * u_right = u_right / max_u_right + * u_top = u_top / max_u_top + * u_bottom = u_bottom / max_u_bottom # <<<<<<<<<<<<<< * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields + * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) */ - if (unlikely(__pyx_v_descr->names == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 850, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 850, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 850, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_bottom, __pyx_v_max_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 + /* "saliency_mbd.pyx":219 + * u_bottom = u_bottom / max_u_bottom * - * for childname in descr.names: - * fields = descr.fields[childname] # <<<<<<<<<<<<<< - * child, new_offset = fields + * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) # <<<<<<<<<<<<<< * + * u_final = (u_left + u_right + u_top + u_bottom) - u_max */ - if (unlikely(__pyx_v_descr->fields == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 851, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_maximum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_maximum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_maximum); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_6 = 1; } - __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 851, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 - * for childname in descr.names: - * fields = descr.fields[childname] - * child, new_offset = fields # <<<<<<<<<<<<<< - * - * if (end - f) - (new_offset - offset[0]) < 15: - */ - if (likely(__pyx_v_fields != Py_None)) { - PyObject* sequence = __pyx_v_fields; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 852, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 852, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 852, __pyx_L1_error) + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_u_left); + __Pyx_GIVEREF(__pyx_v_u_left); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_v_u_left); + __Pyx_INCREF(__pyx_v_u_right); + __Pyx_GIVEREF(__pyx_v_u_right); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_right); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; } - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 852, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_t_3); + __Pyx_INCREF(__pyx_v_u_top); + __Pyx_GIVEREF(__pyx_v_u_top); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_top); __pyx_t_3 = 0; - __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); - __pyx_t_4 = 0; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 854, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 854, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 854, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); - if (unlikely(__pyx_t_6)) { + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_t_1); + __Pyx_INCREF(__pyx_v_u_bottom); + __Pyx_GIVEREF(__pyx_v_u_bottom); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_bottom); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_u_max = __pyx_t_4; + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 + /* "saliency_mbd.pyx":221 + * u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom) * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * u_final = (u_left + u_right + u_top + u_bottom) - u_max # <<<<<<<<<<<<<< * - * if ((child.byteorder == c'>' and little_endian) or + * u_max_final = np.max(u_final) */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 855, __pyx_L1_error) + __pyx_t_4 = PyNumber_Add(__pyx_v_u_left, __pyx_v_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_v_u_top); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_v_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_v_u_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_u_final, __pyx_t_5); + __pyx_t_5 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "saliency_mbd.pyx":223 + * u_final = (u_left + u_right + u_top + u_bottom) - u_max * + * u_max_final = np.max(u_final) # <<<<<<<<<<<<<< + * sal_max = np.max(sal) + * sal = sal / sal_max + u_final / u_max_final */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); } + } + __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_u_final) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_u_final); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_u_max_final = __pyx_t_5; + __pyx_t_5 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "saliency_mbd.pyx":224 * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); - if (!__pyx_t_7) { - goto __pyx_L8_next_or; - } else { - } - __pyx_t_7 = (__pyx_v_little_endian != 0); - if (!__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_L8_next_or:; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 + * u_max_final = np.max(u_final) + * sal_max = np.max(sal) # <<<<<<<<<<<<<< + * sal = sal / sal_max + u_final / u_max_final * - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * # One could encode it in the format string and have Cython */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); - if (__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); } - __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_6 = __pyx_t_7; - __pyx_L7_bool_binop_done:; + } + __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_sal_max = __pyx_t_5; + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":225 + * u_max_final = np.max(u_final) + * sal_max = np.max(sal) + * sal = sal / sal_max + u_final / u_max_final # <<<<<<<<<<<<<< + * + * #postprocessing + */ + __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_v_sal_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_final, __pyx_v_u_max_final); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_9); + __pyx_t_9 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "saliency_mbd.pyx":230 * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - if (unlikely(__pyx_t_6)) { - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * # One could encode it in the format string and have Cython - * # complain instead, BUT: < and > in format strings also imply - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 859, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 859, __pyx_L1_error) - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * # apply centredness map + * sal = sal / np.max(sal) # <<<<<<<<<<<<<< * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + * s = np.mean(sal) */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":869 - * - * # Output padding bytes - * while offset[0] < new_offset: # <<<<<<<<<<<<<< - * f[0] = 120 # "x"; pad byte - * f += 1 - */ - while (1) { - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 869, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 869, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 869, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (!__pyx_t_6) break; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 - * # Output padding bytes - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< - * f += 1 - * offset[0] += 1 - */ - (__pyx_v_f[0]) = 0x78; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte - * f += 1 # <<<<<<<<<<<<<< - * offset[0] += 1 - * - */ - __pyx_v_f = (__pyx_v_f + 1); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 - * f[0] = 120 # "x"; pad byte - * f += 1 - * offset[0] += 1 # <<<<<<<<<<<<<< - * - * offset[0] += child.itemsize - */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + __pyx_t_9 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_5); + __pyx_t_5 = 0; + + /* "saliency_mbd.pyx":232 + * sal = sal / np.max(sal) + * + * s = np.mean(sal) # <<<<<<<<<<<<<< + * cdef double alpha = 50.0 + * cdef double delta = alpha * sqrt(s) + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); } + } + __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_s = __pyx_t_5; + __pyx_t_5 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":874 - * offset[0] += 1 - * - * offset[0] += child.itemsize # <<<<<<<<<<<<<< - * - * if not PyDataType_HASFIELDS(child): - */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876 - * offset[0] += child.itemsize - * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: - */ - __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); - if (__pyx_t_6) { - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 + /* "saliency_mbd.pyx":233 * - * if not PyDataType_HASFIELDS(child): - * t = child.type_num # <<<<<<<<<<<<<< - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") - */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 877, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); - __pyx_t_4 = 0; - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") + * s = np.mean(sal) + * cdef double alpha = 50.0 # <<<<<<<<<<<<<< + * cdef double delta = alpha * sqrt(s) * */ - __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); - if (unlikely(__pyx_t_6)) { + __pyx_v_alpha = 50.0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":234 + * s = np.mean(sal) + * cdef double alpha = 50.0 + * cdef double delta = alpha * sqrt(s) # <<<<<<<<<<<<<< * - * # Until ticket #99 is fixed, use integers to avoid warnings + * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 879, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 879, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_s); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 234, __pyx_L1_error) + __pyx_v_delta = (__pyx_v_alpha * sqrt(__pyx_t_10)); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") + /* "saliency_mbd.pyx":236 + * cdef double delta = alpha * sqrt(s) * + * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) # <<<<<<<<<<<<<< + * cdef int w = sal.shape[0] + * cdef int h = sal.shape[1] */ - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":882 - * - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 882, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 882, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 882, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 98; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 66; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x68; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 72; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x69; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 73; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x6C; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 76; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x71; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 81; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x66; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x64; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x67; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x66; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x64; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x67; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (likely(__pyx_t_6)) { - (__pyx_v_f[0]) = 79; - goto __pyx_L15; - } - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":900 - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * f += 1 - * else: - */ - /*else*/ { - __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 900, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 900, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 900, __pyx_L1_error) - } - __pyx_L15:; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_meshgrid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_arange); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_1) { + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); __pyx_t_1 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_6, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_6, __pyx_t_2); + __pyx_t_4 = 0; + __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 236, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_9 = PyList_GET_ITEM(sequence, 0); + __pyx_t_8 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(__pyx_t_8); + #else + __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext; + index = 0; __pyx_t_9 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_9); + index = 1; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_v_xv = __pyx_t_9; + __pyx_t_9 = 0; + __pyx_v_yv = __pyx_t_8; + __pyx_t_8 = 0; + + /* "saliency_mbd.pyx":237 + * + * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) + * cdef int w = sal.shape[0] # <<<<<<<<<<<<<< + * cdef int h = sal.shape[1] + * cdef double w2 = w/2.0 + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_w = __pyx_t_6; + + /* "saliency_mbd.pyx":238 + * xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0])) + * cdef int w = sal.shape[0] + * cdef int h = sal.shape[1] # <<<<<<<<<<<<<< + * cdef double w2 = w/2.0 + * cdef double h2 = h/2.0 + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_h = __pyx_t_6; + + /* "saliency_mbd.pyx":239 + * cdef int w = sal.shape[0] + * cdef int h = sal.shape[1] + * cdef double w2 = w/2.0 # <<<<<<<<<<<<<< + * cdef double h2 = h/2.0 + * + */ + __pyx_v_w2 = (__pyx_v_w / 2.0); + + /* "saliency_mbd.pyx":240 + * cdef int h = sal.shape[1] + * cdef double w2 = w/2.0 + * cdef double h2 = h/2.0 # <<<<<<<<<<<<<< + * + * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) + */ + __pyx_v_h2 = (__pyx_v_h / 2.0); + + /* "saliency_mbd.pyx":242 + * cdef double h2 = h/2.0 + * + * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) # <<<<<<<<<<<<<< + * + * sal = sal * C + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyNumber_Subtract(__pyx_v_xv, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_t_1); + __Pyx_INCREF(__pyx_int_2); + __Pyx_GIVEREF(__pyx_int_2); + PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_int_2); + __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Subtract(__pyx_v_yv, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_2); + __Pyx_INCREF(__pyx_int_2); + __Pyx_GIVEREF(__pyx_int_2); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2); + __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_1, __pyx_int_2}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_1, __pyx_int_2}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_1); + __Pyx_INCREF(__pyx_int_2); + __Pyx_GIVEREF(__pyx_int_2); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2); + __pyx_t_1 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_int_2}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_int_2}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_t_7); + __Pyx_INCREF(__pyx_int_2); + __Pyx_GIVEREF(__pyx_int_2); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_int_2); + __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyFloat_FromDouble(sqrt(__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_SubtractCObj(__pyx_int_1, __pyx_t_4, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_C = __pyx_t_1; + __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * f += 1 # <<<<<<<<<<<<<< - * else: - * # Cython ignores struct boundary information ("T{...}"), + /* "saliency_mbd.pyx":244 + * C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2)) + * + * sal = sal * C # <<<<<<<<<<<<<< + * + * fv = np.vectorize(f) */ - __pyx_v_f = (__pyx_v_f + 1); + __pyx_t_1 = PyNumber_Multiply(__pyx_v_sal, __pyx_v_C); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_1); + __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876 - * offset[0] += child.itemsize + /* "saliency_mbd.pyx":246 + * sal = sal * C * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: + * fv = np.vectorize(f) # <<<<<<<<<<<<<< + * + * sal = sal / np.max(sal) */ - goto __pyx_L13; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_vectorize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_CFunc_object____object___to_py(__pyx_f_12saliency_mbd_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); } + } + __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_9, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_fv = __pyx_t_1; + __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":905 - * # Cython ignores struct boundary information ("T{...}"), - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< - * return f + /* "saliency_mbd.pyx":248 + * fv = np.vectorize(f) + * + * sal = sal / np.max(sal) # <<<<<<<<<<<<<< * + * sal = fv(sal) */ - /*else*/ { - __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 905, __pyx_L1_error) - __pyx_v_f = __pyx_t_9; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); } - __pyx_L13:; + } + __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 - * cdef tuple fields + /* "saliency_mbd.pyx":250 + * sal = sal / np.max(sal) + * + * sal = fv(sal) # <<<<<<<<<<<<<< * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields + * return sal* 255.0 */ + __Pyx_INCREF(__pyx_v_fv); + __pyx_t_1 = __pyx_v_fv; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_sal); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) - * return f # <<<<<<<<<<<<<< - * + /* "saliency_mbd.pyx":252 + * sal = fv(sal) * + * return sal* 255.0 # <<<<<<<<<<<<<< */ - __pyx_r = __pyx_v_f; + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 - * return () - * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. + /* "saliency_mbd.pyx":133 + * @cython.boundscheck(False) + * @cython.wraparound(False) + * cpdef get_saliency_mbd(np.ndarray img,method='b'): # <<<<<<<<<<<<<< + * # Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS + * img_mean = np.mean(img,axis=(2)) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_child); - __Pyx_XDECREF(__pyx_v_fields); - __Pyx_XDECREF(__pyx_v_childname); - __Pyx_XDECREF(__pyx_v_new_offset); - __Pyx_XDECREF(__pyx_v_t); + __Pyx_XDECREF(__pyx_v_img_mean); + __Pyx_XDECREF(__pyx_v_sal); + __Pyx_XDECREF(__pyx_v_border_thickness); + __Pyx_XDECREF((PyObject *)__pyx_v_img_lab); + __Pyx_XDECREF(__pyx_v_px_left); + __Pyx_XDECREF(__pyx_v_px_right); + __Pyx_XDECREF(__pyx_v_px_top); + __Pyx_XDECREF(__pyx_v_px_bottom); + __Pyx_XDECREF(__pyx_v_px_mean_left); + __Pyx_XDECREF(__pyx_v_px_mean_right); + __Pyx_XDECREF(__pyx_v_px_mean_top); + __Pyx_XDECREF(__pyx_v_px_mean_bottom); + __Pyx_XDECREF(__pyx_v_cov_left); + __Pyx_XDECREF(__pyx_v_cov_right); + __Pyx_XDECREF(__pyx_v_cov_top); + __Pyx_XDECREF(__pyx_v_cov_bottom); + __Pyx_XDECREF(__pyx_v_u_left); + __Pyx_XDECREF(__pyx_v_u_right); + __Pyx_XDECREF(__pyx_v_u_top); + __Pyx_XDECREF(__pyx_v_u_bottom); + __Pyx_XDECREF(__pyx_v_u_final); + __Pyx_XDECREF(__pyx_v_img_lab_unrolled); + __Pyx_XDECREF(__pyx_v_px_mean_left_2); + __Pyx_XDECREF(__pyx_v_px_mean_right_2); + __Pyx_XDECREF(__pyx_v_px_mean_top_2); + __Pyx_XDECREF(__pyx_v_px_mean_bottom_2); + __Pyx_XDECREF(__pyx_v_max_u_left); + __Pyx_XDECREF(__pyx_v_max_u_right); + __Pyx_XDECREF(__pyx_v_max_u_top); + __Pyx_XDECREF(__pyx_v_max_u_bottom); + __Pyx_XDECREF(__pyx_v_u_max); + __Pyx_XDECREF(__pyx_v_u_max_final); + __Pyx_XDECREF(__pyx_v_sal_max); + __Pyx_XDECREF(__pyx_v_s); + __Pyx_XDECREF(__pyx_v_xv); + __Pyx_XDECREF(__pyx_v_yv); + __Pyx_XDECREF(__pyx_v_C); + __Pyx_XDECREF(__pyx_v_fv); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - -static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { +/* Python wrapper */ +static PyObject *__pyx_pw_12saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_pw_12saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_img = 0; + PyObject *__pyx_v_method = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("set_array_base", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 - * - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< - * PyArray_SetBaseObject(arr, base) - * - */ - Py_INCREF(__pyx_v_base); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< - * - * cdef inline object get_array_base(ndarray arr): - */ - (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ + __Pyx_RefNannySetupContext("get_saliency_mbd (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_img,&__pyx_n_s_method,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)__pyx_n_s_b); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_img)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 133, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_img = ((PyArrayObject *)values[0]); + __pyx_v_method = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 133, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 133, __pyx_L1_error) + __pyx_r = __pyx_pf_12saliency_mbd_get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method); /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; __Pyx_RefNannyFinishContext(); + return __pyx_r; } -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025 - * PyArray_SetBaseObject(arr, base) +static PyObject *__pyx_pf_12saliency_mbd_get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_saliency_mbd", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.method = __pyx_v_method; + __pyx_t_1 = __pyx_f_12saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { - PyObject *__pyx_v_base; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("get_array_base", 0); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":735 * - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< - * if base is NULL: - * return None + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): */ - __pyx_v_base = PyArray_BASE(__pyx_v_arr); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * */ - __pyx_t_1 = ((__pyx_v_base == NULL) != 0); - if (__pyx_t_1) { - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 - * base = PyArray_BASE(arr) - * if base is NULL: - * return None # <<<<<<<<<<<<<< - * return base + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":737 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) * */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base - */ - } +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 - * if base is NULL: - * return None - * return base # <<<<<<<<<<<<<< + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":738 * - * # Versions of the import_* functions which are more suitable for + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_base)); - __pyx_r = ((PyObject *)__pyx_v_base); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025 - * PyArray_SetBaseObject(arr, base) + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":737 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: */ /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * _import_array() +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":740 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * */ -static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { - int __pyx_r; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_array", 0); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 - * cdef inline int import_array() except -1: - * try: - * _import_array() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") - */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1035, __pyx_L3_error) + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":741 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 - * try: - * _import_array() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.multiarray failed to import") + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":740 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) * */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1036, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 - * _import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":743 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) * - * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1037, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1037, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":744 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * _import_array() + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":743 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039 - * raise ImportError("numpy.core.multiarray failed to import") +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":746 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() */ -static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { - int __pyx_r; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_umath", 0); + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":747 * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 - * cdef inline int import_umath() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":746 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1041, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":749 + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":750 * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1042, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":751 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":750 * - * cdef inline int import_ufunc() except -1: + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1043, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1043, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; + } - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":753 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; } - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039 - * raise ImportError("numpy.core.multiarray failed to import") + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":749 + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 - * raise ImportError("numpy.core.umath failed to import") +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":868 + * int _import_umath() except -1 * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ -static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { - int __pyx_r; +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":869 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * + */ + Py_INCREF(__pyx_v_base); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":870 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":868 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":872 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":873 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":874 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":875 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":874 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":876 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":872 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":880 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; @@ -5824,11 +6637,143 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_ufunc", 0); + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":882 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 882, __pyx_L3_error) + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":883 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") * - * cdef inline int import_ufunc() except -1: + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 883, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":884 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 884, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 884, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":880 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":886 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: @@ -5842,18 +6787,18 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 - * cdef inline int import_ufunc() except -1: + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":888 + * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1047, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 888, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":887 * - * cdef inline int import_ufunc() except -1: + * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: @@ -5865,37 +6810,40 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":889 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") + * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1048, __pyx_L5_except_error) + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 889, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":890 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1049, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 890, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1049, __pyx_L5_except_error) + __PYX_ERR(1, 890, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":887 * - * cdef inline int import_ufunc() except -1: + * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: @@ -5908,10 +6856,10 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 - * raise ImportError("numpy.core.umath failed to import") + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":886 + * raise ImportError("numpy.core.multiarray failed to import") * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ @@ -5924,22 +6872,389 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyMethodDef __pyx_methods[] = { - {"get_saliency_mbd", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_12saliency_mbd_3get_saliency_mbd, METH_VARARGS|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_saliency_mbd(PyObject* module); /*proto*/ +/* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":894 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L3_error) + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":895 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 895, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":896 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef extern from *: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 896, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 896, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cfunc.to_py":65 + * @cname("__Pyx_CFunc_object____object___to_py") + * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ): + * def wrap(object x): # <<<<<<<<<<<<<< + * """wrap(x)""" + * return f(x) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static char __pyx_doc_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap[] = "wrap(x)"; +static PyMethodDef __pyx_mdef_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap = {"wrap", (PyCFunction)__pyx_pw_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap, METH_O, __pyx_doc_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap}; +static PyObject *__pyx_pw_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("wrap (wrapper)", 0); + __pyx_r = __pyx_pf_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap(PyObject *__pyx_self, PyObject *__pyx_v_x) { + struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *__pyx_cur_scope; + struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *__pyx_outer_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("wrap", 0); + __pyx_outer_scope = (struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *) __Pyx_CyFunction_GetClosure(__pyx_self); + __pyx_cur_scope = __pyx_outer_scope; + + /* "cfunc.to_py":67 + * def wrap(object x): + * """wrap(x)""" + * return f(x) # <<<<<<<<<<<<<< + * return wrap + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_cur_scope->__pyx_v_f(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cfunc.to_py":65 + * @cname("__Pyx_CFunc_object____object___to_py") + * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ): + * def wrap(object x): # <<<<<<<<<<<<<< + * """wrap(x)""" + * return f(x) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_object____object___to_py.wrap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cfunc.to_py":64 + * + * @cname("__Pyx_CFunc_object____object___to_py") + * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ): # <<<<<<<<<<<<<< + * def wrap(object x): + * """wrap(x)""" + */ + +static PyObject *__Pyx_CFunc_object____object___to_py(PyObject *(*__pyx_v_f)(PyObject *)) { + struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *__pyx_cur_scope; + PyObject *__pyx_v_wrap = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_CFunc_object____object___to_py", 0); + __pyx_cur_scope = (struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *)__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____object___to_py(__pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____object___to_py, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(2, 64, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_f = __pyx_v_f; + + /* "cfunc.to_py":65 + * @cname("__Pyx_CFunc_object____object___to_py") + * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ): + * def wrap(object x): # <<<<<<<<<<<<<< + * """wrap(x)""" + * return f(x) + */ + __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap, 0, __pyx_n_s_Pyx_CFunc_object____object___t, ((PyObject*)__pyx_cur_scope), __pyx_n_s_cfunc_to_py, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_wrap = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cfunc.to_py":68 + * """wrap(x)""" + * return f(x) + * return wrap # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_wrap); + __pyx_r = __pyx_v_wrap; + goto __pyx_L0; + + /* "cfunc.to_py":64 + * + * @cname("__Pyx_CFunc_object____object___to_py") + * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ): # <<<<<<<<<<<<<< + * def wrap(object x): + * """wrap(x)""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_object____object___to_py", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_wrap); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *__pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____object___to_py[8]; +static int __pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py = 0; + +static PyObject *__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____object___to_py(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py)))) { + o = (PyObject*)__pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____object___to_py[--__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py]; + memset(o, 0, sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py)); + (void) PyObject_INIT(o, t); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_object____object___to_py(PyObject *o) { + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py)))) { + __pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____object___to_py[__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py++] = ((struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static PyTypeObject __pyx_scope_struct____Pyx_CFunc_object____object___to_py = { + PyVarObject_HEAD_INIT(0, 0) + "saliency_mbd.__pyx_scope_struct____Pyx_CFunc_object____object___to_py", /*tp_name*/ + sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_object____object___to_py, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____object___to_py, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"get_saliency_mbd", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_12saliency_mbd_1get_saliency_mbd, METH_VARARGS|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_saliency_mbd(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_saliency_mbd}, @@ -5978,52 +7293,69 @@ static struct PyModuleDef __pyx_moduledef = { #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, - {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, - {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, - {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_Pyx_CFunc_object____object___t, __pyx_k_Pyx_CFunc_object____object___t, sizeof(__pyx_k_Pyx_CFunc_object____object___t), 0, 0, 1, 1}, + {&__pyx_n_s_T, __pyx_k_T, sizeof(__pyx_k_T), 0, 0, 1, 1}, + {&__pyx_n_s_VI, __pyx_k_VI, sizeof(__pyx_k_VI), 0, 0, 1, 1}, + {&__pyx_n_s_arange, __pyx_k_arange, sizeof(__pyx_k_arange), 0, 0, 1, 1}, {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1}, {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, + {&__pyx_n_s_cdist, __pyx_k_cdist, sizeof(__pyx_k_cdist), 0, 0, 1, 1}, + {&__pyx_n_s_cfunc_to_py, __pyx_k_cfunc_to_py, sizeof(__pyx_k_cfunc_to_py), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_color, __pyx_k_color, sizeof(__pyx_k_color), 0, 0, 1, 1}, {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, - {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1}, + {&__pyx_n_s_cov, __pyx_k_cov, sizeof(__pyx_k_cov), 0, 0, 1, 1}, + {&__pyx_n_s_distance, __pyx_k_distance, sizeof(__pyx_k_distance), 0, 0, 1, 1}, {&__pyx_n_s_full_like, __pyx_k_full_like, sizeof(__pyx_k_full_like), 0, 0, 1, 1}, {&__pyx_n_s_img, __pyx_k_img, sizeof(__pyx_k_img), 0, 0, 1, 1}, {&__pyx_n_s_img_as_float, __pyx_k_img_as_float, sizeof(__pyx_k_img_as_float), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_inv, __pyx_k_inv, sizeof(__pyx_k_inv), 0, 0, 1, 1}, + {&__pyx_n_s_linalg, __pyx_k_linalg, sizeof(__pyx_k_linalg), 0, 0, 1, 1}, + {&__pyx_n_s_mahalanobis, __pyx_k_mahalanobis, sizeof(__pyx_k_mahalanobis), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, + {&__pyx_n_s_maximum, __pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 0, 1, 1}, {&__pyx_n_s_mean, __pyx_k_mean, sizeof(__pyx_k_mean), 0, 0, 1, 1}, + {&__pyx_n_s_meshgrid, __pyx_k_meshgrid, sizeof(__pyx_k_meshgrid), 0, 0, 1, 1}, {&__pyx_n_s_method, __pyx_k_method, sizeof(__pyx_k_method), 0, 0, 1, 1}, {&__pyx_n_s_minimize, __pyx_k_minimize, sizeof(__pyx_k_minimize), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, - {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, + {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_saliency_mbd, __pyx_k_saliency_mbd, sizeof(__pyx_k_saliency_mbd), 0, 0, 1, 1}, + {&__pyx_n_s_reshape, __pyx_k_reshape, sizeof(__pyx_k_reshape), 0, 0, 1, 1}, + {&__pyx_n_s_rgb2lab, __pyx_k_rgb2lab, sizeof(__pyx_k_rgb2lab), 0, 0, 1, 1}, {&__pyx_n_s_scipy, __pyx_k_scipy, sizeof(__pyx_k_scipy), 0, 0, 1, 1}, {&__pyx_n_s_scipy_optimize, __pyx_k_scipy_optimize, sizeof(__pyx_k_scipy_optimize), 0, 0, 1, 1}, {&__pyx_n_s_scipy_spatial_distance, __pyx_k_scipy_spatial_distance, sizeof(__pyx_k_scipy_spatial_distance), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, {&__pyx_n_s_skimage, __pyx_k_skimage, sizeof(__pyx_k_skimage), 0, 0, 1, 1}, {&__pyx_n_s_skimage_io, __pyx_k_skimage_io, sizeof(__pyx_k_skimage_io), 0, 0, 1, 1}, {&__pyx_n_s_skimage_util, __pyx_k_skimage_util, sizeof(__pyx_k_skimage_util), 0, 0, 1, 1}, + {&__pyx_n_s_spatial, __pyx_k_spatial, sizeof(__pyx_k_spatial), 0, 0, 1, 1}, + {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, - {&__pyx_kp_s_tasks_segmentation_saliency_dete, __pyx_k_tasks_segmentation_saliency_dete, sizeof(__pyx_k_tasks_segmentation_saliency_dete), 0, 0, 1, 0}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_vectorize, __pyx_k_vectorize, sizeof(__pyx_k_vectorize), 0, 0, 1, 1}, + {&__pyx_n_s_wrap, __pyx_k_wrap, sizeof(__pyx_k_wrap), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, + {&__pyx_n_s_xrange, __pyx_k_xrange, sizeof(__pyx_k_xrange), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 33, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 855, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1037, __pyx_L1_error) + #if PY_MAJOR_VERSION >= 3 + __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_xrange) __PYX_ERR(0, 32, __pyx_L1_error) + #else + __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_xrange); if (!__pyx_builtin_xrange) __PYX_ERR(0, 32, __pyx_L1_error) + #endif + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; @@ -6034,8 +7366,8 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "saliency_mbd.pyx":113 - * U = np.copy(img) - * D = np.full_like(img, 10000000) + * cdef np.ndarray[double, ndim=2] U = np.copy(img) + * cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000) * D[0,:] = 0 # <<<<<<<<<<<<<< * D[-1,:] = 0 * D[:,0] = 0 @@ -6048,7 +7380,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__2); /* "saliency_mbd.pyx":114 - * D = np.full_like(img, 10000000) + * cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000) * D[0,:] = 0 * D[-1,:] = 0 # <<<<<<<<<<<<<< * D[:,0] = 0 @@ -6080,94 +7412,61 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":152 + * px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:] * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * px_mean_left = np.mean(px_left,axis=(0,1)) # <<<<<<<<<<<<<< + * px_mean_right = np.mean(px_right,axis=(0,1)) + * px_mean_top = np.mean(px_top,axis=(0,1)) */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 272, __pyx_L1_error) + __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + /* "saliency_mbd.pyx":185 + * img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3) + * + * px_mean_left_2 = np.zeros((1,3)) # <<<<<<<<<<<<<< + * px_mean_left_2[0,:] = px_mean_left * - * info.buf = PyArray_DATA(self) */ - __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 276, __pyx_L1_error) + __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_3); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 185, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - */ - __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< - * - * if ((child.byteorder == c'>' and little_endian) or - */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 855, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< - * - * # Until ticket #99 is fixed, use integers to avoid warnings - */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 879, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 - * _import_array() + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":884 + * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 1037, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 + /* "../conda/envs/urobotics/lib/python3.7/site-packages/numpy/__init__.pxd":890 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 1043, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); - /* "saliency_mbd.pyx":127 - * return D - * - * def f(x): # <<<<<<<<<<<<<< - * b = 10.0 - * return 1.0 / (1.0 + exp(-b*(x - 0.5))) + /* "cfunc.to_py":65 + * @cname("__Pyx_CFunc_object____object___to_py") + * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ): + * def wrap(object x): # <<<<<<<<<<<<<< + * """wrap(x)""" + * return f(x) */ - __pyx_tuple__13 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_b); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tasks_segmentation_saliency_dete, __pyx_n_s_f, 127, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 127, __pyx_L1_error) + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_wrap, 65, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(2, 65, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -6180,7 +7479,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { __pyx_float_0_5 = PyFloat_FromDouble(0.5); if (unlikely(!__pyx_float_0_5)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_float_255_0 = PyFloat_FromDouble(255.0); if (unlikely(!__pyx_float_255_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_10000000 = PyInt_FromLong(10000000L); if (unlikely(!__pyx_int_10000000)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; @@ -6222,11 +7523,25 @@ static int __Pyx_modinit_function_export_code(void) { static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ + if (PyType_Ready(&__pyx_scope_struct____Pyx_CFunc_object____object___to_py) < 0) __PYX_ERR(2, 64, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_scope_struct____Pyx_CFunc_object____object___to_py.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_scope_struct____Pyx_CFunc_object____object___to_py.tp_dictoffset && __pyx_scope_struct____Pyx_CFunc_object____object___to_py.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_scope_struct____Pyx_CFunc_object____object___to_py.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + __pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____object___to_py = &__pyx_scope_struct____Pyx_CFunc_object____object___to_py; __Pyx_RefNannyFinishContext(); return 0; -} + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations @@ -6236,7 +7551,7 @@ static int __Pyx_modinit_type_import_code(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 @@ -6245,20 +7560,20 @@ static int __Pyx_modinit_type_import_code(void) { sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 917, __pyx_L1_error) + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 764, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -6479,7 +7794,7 @@ if (!__Pyx_RefNanny) { (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); - (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); @@ -6596,18 +7911,6 @@ if (!__Pyx_RefNanny) { */ __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 12, __pyx_L1_error) - /* "saliency_mbd.pyx":127 - * return D - * - * def f(x): # <<<<<<<<<<<<<< - * b = 10.0 - * return 1.0 / (1.0 + exp(-b*(x - 0.5))) - */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12saliency_mbd_1f, NULL, __pyx_n_s_saliency_mbd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_f, __pyx_t_1) < 0) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "saliency_mbd.pyx":1 * import sys # <<<<<<<<<<<<<< * import numpy as np @@ -6618,12 +7921,12 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045 - * raise ImportError("numpy.core.umath failed to import") + /* "cfunc.to_py":64 * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * @cname("__Pyx_CFunc_object____object___to_py") + * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ): # <<<<<<<<<<<<<< + * def wrap(object x): + * """wrap(x)""" */ /*--- Wrapped vars code ---*/ @@ -7257,142 +8560,6 @@ fail:; return -1; } -/* GetItemInt */ - static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (!j) return NULL; - r = PyObject_GetItem(o, j); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyList_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { - PyObject *r = PyList_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyTuple_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); - } - } - return m->sq_item(o, i); - } - } -#else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); - } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -} - -/* SetItemInt */ - static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { - int r; - if (!j) return -1; - r = PyObject_SetItem(o, j, v); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, - CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { - PyObject* old = PyList_GET_ITEM(o, n); - Py_INCREF(v); - PyList_SET_ITEM(o, n, v); - Py_DECREF(old); - return 1; - } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_ass_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return -1; - PyErr_Clear(); - } - } - return m->sq_ass_item(o, i, v); - } - } -#else -#if CYTHON_COMPILING_IN_PYPY - if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) -#else - if (is_list || PySequence_Check(o)) -#endif - { - return PySequence_SetItem(o, i, v); - } -#endif - return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); -} - /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { @@ -7716,113 +8883,547 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec #endif } } - return __Pyx__PyObject_CallOneArg(func, arg); -} -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* None */ + static CYTHON_INLINE long __Pyx_mod_long(long a, long b) { + long r = a % b; + r += ((r != 0) & ((r ^ b) < 0)) * b; + return r; +} + +/* PyFloatBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { + const double b = floatval; + double a, result; + (void)inplace; + (void)zerodivision_check; + if (likely(PyFloat_CheckExact(op1))) { + a = PyFloat_AS_DOUBLE(op1); + + } else + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + a = (double) PyInt_AS_LONG(op1); + + } else + #endif + if (likely(PyLong_CheckExact(op1))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + switch (size) { + case 0: a = 0.0; break; + case -1: a = -(double) digits[0]; break; + case 1: a = (double) digits[0]; break; + case -2: + case 2: + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) { + a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -2) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + case -3: + case 3: + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) { + a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -3) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + case -4: + case 4: + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) { + a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { + if (size == -4) + a = -a; + break; + } + } + CYTHON_FALLTHROUGH; + default: + #else + { + #endif + a = PyLong_AsDouble(op1); + if (unlikely(a == -1.0 && PyErr_Occurred())) return NULL; + + } + } else { + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); + } + + PyFPE_START_PROTECT("subtract", return NULL) + result = a - b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); +} +#endif + +/* PyIntFromDouble */ + #if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value) { + if (value >= (double)LONG_MIN && value <= (double)LONG_MAX) { + return PyInt_FromLong((long)value); + } + return PyLong_FromDouble(value); +} +#endif + +/* GetItemInt */ + static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ObjectGetItem */ + #if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* PyIntBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + } + x = a - b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); } #endif -/* None */ - static CYTHON_INLINE long __Pyx_mod_long(long a, long b) { - long r = a % b; - r += ((r != 0) & ((r ^ b) < 0)) * b; - return r; +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } -/* ExtTypeTest */ - static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", - Py_TYPE(obj)->tp_name, type->tp_name); return 0; +#endif } -/* PyFloatBinop */ - #if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) { - const double b = floatval; - double a, result; +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* PyIntBinop */ + #if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { (void)inplace; (void)zerodivision_check; - if (likely(PyFloat_CheckExact(op1))) { - a = PyFloat_AS_DOUBLE(op1); - - } else #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - a = (double) PyInt_AS_LONG(op1); - - } else + if (likely(PyInt_CheckExact(op2))) { + const long a = intval; + long x; + long b = PyInt_AS_LONG(op2); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } #endif - if (likely(PyLong_CheckExact(op1))) { - #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)op1)->ob_digit; - const Py_ssize_t size = Py_SIZE(op1); - switch (size) { - case 0: a = 0.0; break; - case -1: a = -(double) digits[0]; break; - case 1: a = (double) digits[0]; break; - case -2: - case 2: - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) { - a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { - if (size == -2) - a = -a; + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op2))) { + const long a = intval; + long b, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG lla = intval; + PY_LONG_LONG llb, llx; +#endif + const digit* digits = ((PyLongObject*)op2)->ob_digit; + const Py_ssize_t size = Py_SIZE(op2); + if (likely(__Pyx_sst_abs(size) <= 1)) { + b = likely(size) ? digits[0] : 0; + if (size == -1) b = -b; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + b = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif } - } - CYTHON_FALLTHROUGH; - case -3: - case 3: - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) { - a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { - if (size == -3) - a = -a; + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + b = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif } - } - CYTHON_FALLTHROUGH; - case -4: - case 4: - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) { - a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) { - if (size == -4) - a = -a; + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + b = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif } - } - CYTHON_FALLTHROUGH; - default: - #else - { - #endif - a = PyLong_AsDouble(op1); - if (unlikely(a == -1.0 && PyErr_Occurred())) return NULL; - + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + b = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + b = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + llb = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + b = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + llb = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } } - } else { - return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); - } + x = a - b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); +#endif - PyFPE_START_PROTECT("subtract", return NULL) - result = a - b; - PyFPE_END_PROTECT(result) - return PyFloat_FromDouble(result); + + } + #endif + if (PyFloat_CheckExact(op2)) { + const long a = intval; + double b = PyFloat_AS_DOUBLE(op2); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); } #endif @@ -7959,34 +9560,189 @@ static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double num_expected = num_max; more_or_less = "at most"; } - if (exact) { - more_or_less = "exactly"; + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* ArgTypeTest */ + static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* GetTopmostException */ + #if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } +#endif -/* ArgTypeTest */ - static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; - #endif + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; } /* RaiseException */ @@ -8148,202 +9904,701 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } #endif -/* DictGetItem */ - #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { - PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - if (unlikely(PyTuple_Check(key))) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) { - PyErr_SetObject(PyExc_KeyError, args); - Py_DECREF(args); - } - } else { - PyErr_SetObject(PyExc_KeyError, key); - } +/* FetchCommonType */ + static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; } - return NULL; + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CythonFunctionShared */ + #include +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; } Py_INCREF(value); - return value; + op->func_doc = value; + Py_XDECREF(tmp); + return 0; } +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); #endif - -/* RaiseTooManyValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + if (unlikely(op == NULL)) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; } - -/* RaiseNeedMoreValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); } - -/* RaiseNoneIterError */ - static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); } - -/* GetTopmostException */ - #if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && - exc_info->previous_item != NULL) - { - exc_info = exc_info->previous_item; + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); } - return exc_info; + return 0; } +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ +#if PY_MAJOR_VERSION < 3 + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; #endif - -/* SaveResetException */ - #if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - *type = exc_info->exc_type; - *value = exc_info->exc_value; - *tb = exc_info->exc_traceback; - #else - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - #endif - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); -} -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = type; - exc_info->exc_value = value; - exc_info->exc_traceback = tb; - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = type; - tstate->exc_value = value; - tstate->exc_traceback = tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); + return __Pyx_PyMethod_New(func, obj, type); } -#endif - -/* PyErrExceptionMatches */ - #if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ #if PY_MAJOR_VERSION >= 3 - for (i=0; i", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; + argc = PyTuple_GET_SIZE(args); + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); } + return result; +} +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, #endif - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ + static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; } -#endif -/* GetException */ - #if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) -#endif -{ - PyObject *local_type, *local_value, *local_tb; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - local_type = tstate->curexc_type; - local_value = tstate->curexc_value; - local_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#else - PyErr_Fetch(&local_type, &local_value, &local_tb); -#endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE - if (unlikely(tstate->curexc_type)) +/* PyObject_GenericGetAttrNoDict */ + #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'%.50s' object has no attribute '%U'", + tp->tp_name, attr_name); #else - if (unlikely(PyErr_Occurred())) + "'%.50s' object has no attribute '%.400s'", + tp->tp_name, PyString_AS_STRING(attr_name)); #endif - goto bad; - #if PY_MAJOR_VERSION >= 3 - if (local_tb) { - if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) - goto bad; + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif - Py_XINCREF(local_tb); - Py_XINCREF(local_type); - Py_XINCREF(local_value); - *type = local_type; - *value = local_value; - *tb = local_tb; -#if CYTHON_FAST_THREAD_STATE - #if CYTHON_USE_EXC_INFO_STACK { - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = local_type; - exc_info->exc_value = local_value; - exc_info->exc_traceback = local_tb; + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } } - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = local_type; - tstate->exc_value = local_value; - tstate->exc_traceback = local_tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -#else - PyErr_SetExcInfo(local_type, local_value, local_tb); -#endif - return 0; -bad: - *type = 0; - *value = 0; - *tb = 0; - Py_XDECREF(local_type); - Py_XDECREF(local_value); - Py_XDECREF(local_tb); - return -1; + return descr; } +#endif /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType @@ -8695,7 +10950,6 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); - if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } @@ -8707,7 +10961,6 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return; } if ((0)) {} - else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); view->obj = NULL; Py_DECREF(obj); } @@ -8745,6 +10998,37 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { } } +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) @@ -8768,24 +11052,24 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { } /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) { + const Py_intptr_t neg_one = (Py_intptr_t) ((Py_intptr_t) 0 - (Py_intptr_t) 1), const_zero = (Py_intptr_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { + if (sizeof(Py_intptr_t) < sizeof(long)) { return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { + } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { - if (sizeof(int) <= sizeof(long)) { + if (sizeof(Py_intptr_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } @@ -8793,7 +11077,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(int), + return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t), little, !is_unsigned); } } @@ -9106,37 +11390,6 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif #endif -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { - const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(enum NPY_TYPES) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(enum NPY_TYPES) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), - little, !is_unsigned); - } -} - /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; diff --git a/perception/tasks/segmentation/saliency_detection/saliency_mbd.html b/perception/tasks/segmentation/saliency_detection/saliency_mbd.html index 1f32e95..7ad925d 100644 --- a/perception/tasks/segmentation/saliency_detection/saliency_mbd.html +++ b/perception/tasks/segmentation/saliency_detection/saliency_mbd.html @@ -287,10 +287,10 @@ .cython.score-253 {background-color: #FFFF09;} .cython.score-254 {background-color: #FFFF09;} pre { line-height: 125%; margin: 0; } -td.linenos pre { color: #000000; background-color: #f0f0f0; padding-left: 5px; padding-right: 5px; } -span.linenos { color: #000000; background-color: #f0f0f0; padding-left: 5px; padding-right: 5px; } -td.linenos pre.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } -span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; } +span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; } +td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; } +span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; } .cython .hll { background-color: #ffffcc } .cython { background: #f8f8f8; } .cython .c { color: #408080; font-style: italic } /* Comment */ @@ -435,12 +435,13 @@ 
  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 12, __pyx_L1_error)
 
 013: 
 014: @cython.boundscheck(False)
-
+015: cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
-
static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) {
+
 015: @cython.wraparound(False)

+
+016: cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):

+
static PyObject *__pyx_f_12saliency_mbd_raster_scan(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) {
   int __pyx_v_n_rows;
   int __pyx_v_n_cols;
-  int __pyx_v_x;
-  int __pyx_v_y;
+  Py_ssize_t __pyx_v_x;
+  Py_ssize_t __pyx_v_y;
   double __pyx_v_ix;
   double __pyx_v_d;
   double __pyx_v_u1;
@@ -478,29 +479,27 @@
   __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D;
   {
     __Pyx_BufFmt_StackElem __pyx_stack[1];
-    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error)
   }
   __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1];
   {
     __Pyx_BufFmt_StackElem __pyx_stack[1];
-    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error)
   }
   __pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1];
   {
     __Pyx_BufFmt_StackElem __pyx_stack[1];
-    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error)
   }
   __pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1];
   {
     __Pyx_BufFmt_StackElem __pyx_stack[1];
-    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 16, __pyx_L1_error)
   }
   __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1];
 /* … */
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_9);
   { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
     __Pyx_PyThreadState_declare
     __Pyx_PyThreadState_assign
@@ -523,260 +522,196 @@
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
-
 016: 	cdef int n_rows

-
 017: 	cdef int n_cols

-
 018: 

-
+019: 	n_rows = len(img)

-
  __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_img)); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error)
-  __pyx_v_n_rows = __pyx_t_1;
-
+020: 	n_cols = len(img[0])

-
  __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 20, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_n_cols = __pyx_t_1;
-
 021: 

-
 022: 	cdef int x

-
 023: 	cdef int y

-
 024: 	cdef double ix

-
 025: 	cdef double d

-
 026: 	cdef double u1

-
 027: 	cdef double l1

-
 028: 	cdef double u2

-
 029: 	cdef double l2

-
 030: 	cdef double b1

-
 031: 	cdef double b2

-
 032: 

-
+033: 	for x in range(1,n_rows - 1):

-
  __pyx_t_3 = (__pyx_v_n_rows - 1);
-  __pyx_t_4 = __pyx_t_3;
-  for (__pyx_t_5 = 1; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
-    __pyx_v_x = __pyx_t_5;
-
+034: 		for y in range(1,n_cols - 1):

-
    __pyx_t_6 = (__pyx_v_n_cols - 1);
-    __pyx_t_7 = __pyx_t_6;
-    for (__pyx_t_8 = 1; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
-      __pyx_v_y = __pyx_t_8;
-
+035: 			ix = img[x][y]

-
      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 35, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_v_ix = __pyx_t_10;
-
+036: 			d = D[x][y]

-
      __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 36, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_v_d = __pyx_t_10;
-
 037: 

-
+038: 			u1 = U[x-1][y]

-
      __pyx_t_11 = (__pyx_v_x - 1);
-      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 38, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_v_u1 = __pyx_t_10;
-
+039: 			l1 = L[x-1][y]

-
      __pyx_t_11 = (__pyx_v_x - 1);
-      __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 39, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_v_l1 = __pyx_t_10;
-
 040: 

-
+041: 			u2 = U[x][y-1]

-
      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_11 = (__pyx_v_y - 1);
-      __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 41, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_9); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_v_u2 = __pyx_t_10;
-
+042: 			l2 = L[x][y-1]

-
      __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 42, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_11 = (__pyx_v_y - 1);
-      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_v_l2 = __pyx_t_10;
-
 043: 

-
+044: 			b1 = max(u1,ix) - min(l1,ix)

-
      __pyx_t_10 = __pyx_v_ix;
-      __pyx_t_12 = __pyx_v_u1;
-      if (((__pyx_t_10 > __pyx_t_12) != 0)) {
-        __pyx_t_13 = __pyx_t_10;
+
 017: 	# cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double)

+
+018: 	cdef int n_rows = img.shape[0]

+
  __pyx_v_n_rows = (__pyx_v_img->dimensions[0]);
+
+019: 	cdef int n_cols = img.shape[1]

+
  __pyx_v_n_cols = (__pyx_v_img->dimensions[1]);
+
 020: 

+
 021: 

+
 022: 	cdef Py_ssize_t x, y

+
 023: 	cdef double ix

+
 024: 	cdef double d

+
 025: 	cdef double u1

+
 026: 	cdef double l1

+
 027: 	cdef double u2

+
 028: 	cdef double l2

+
 029: 	cdef double b1

+
 030: 	cdef double b2

+
 031: 

+
+032: 	for x in xrange(1,n_rows - 1):

+
  __pyx_t_1 = (__pyx_v_n_rows - 1);
+  __pyx_t_2 = __pyx_t_1;
+  for (__pyx_t_3 = 1; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_x = __pyx_t_3;
+
+033: 		for y in xrange(1,n_cols - 1):

+
    __pyx_t_4 = (__pyx_v_n_cols - 1);
+    __pyx_t_5 = __pyx_t_4;
+    for (__pyx_t_6 = 1; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+      __pyx_v_y = __pyx_t_6;
+
+034: 			ix = img[x, y]

+
      __pyx_t_7 = __pyx_v_x;
+      __pyx_t_8 = __pyx_v_y;
+      __pyx_v_ix = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_img.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_img.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_img.diminfo[1].strides));
+
+035: 			d = D[x,y]

+
      __pyx_t_8 = __pyx_v_x;
+      __pyx_t_7 = __pyx_v_y;
+      __pyx_v_d = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_D.diminfo[1].strides));
+
 036: 

+
+037: 			u1 = U[x-1,y]

+
      __pyx_t_7 = (__pyx_v_x - 1);
+      __pyx_t_8 = __pyx_v_y;
+      __pyx_v_u1 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_U.diminfo[1].strides));
+
+038: 			l1 = L[x-1,y]

+
      __pyx_t_8 = (__pyx_v_x - 1);
+      __pyx_t_7 = __pyx_v_y;
+      __pyx_v_l1 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_L.diminfo[1].strides));
+
 039: 

+
+040: 			u2 = U[x,y-1]

+
      __pyx_t_7 = __pyx_v_x;
+      __pyx_t_8 = (__pyx_v_y - 1);
+      __pyx_v_u2 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_U.diminfo[1].strides));
+
+041: 			l2 = L[x,y-1]

+
      __pyx_t_8 = __pyx_v_x;
+      __pyx_t_7 = (__pyx_v_y - 1);
+      __pyx_v_l2 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_L.diminfo[1].strides));
+
 042: 

+
+043: 			b1 = max(u1,ix) - min(l1,ix)

+
      __pyx_t_9 = __pyx_v_ix;
+      __pyx_t_10 = __pyx_v_u1;
+      if (((__pyx_t_9 > __pyx_t_10) != 0)) {
+        __pyx_t_11 = __pyx_t_9;
       } else {
-        __pyx_t_13 = __pyx_t_12;
+        __pyx_t_11 = __pyx_t_10;
       }
-      __pyx_t_10 = __pyx_v_ix;
-      __pyx_t_12 = __pyx_v_l1;
-      if (((__pyx_t_10 < __pyx_t_12) != 0)) {
-        __pyx_t_14 = __pyx_t_10;
+      __pyx_t_9 = __pyx_v_ix;
+      __pyx_t_10 = __pyx_v_l1;
+      if (((__pyx_t_9 < __pyx_t_10) != 0)) {
+        __pyx_t_12 = __pyx_t_9;
       } else {
-        __pyx_t_14 = __pyx_t_12;
+        __pyx_t_12 = __pyx_t_10;
       }
-      __pyx_v_b1 = (__pyx_t_13 - __pyx_t_14);
-
+045: 			b2 = max(u2,ix) - min(l2,ix)

-
      __pyx_t_14 = __pyx_v_ix;
-      __pyx_t_13 = __pyx_v_u2;
-      if (((__pyx_t_14 > __pyx_t_13) != 0)) {
-        __pyx_t_10 = __pyx_t_14;
+      __pyx_v_b1 = (__pyx_t_11 - __pyx_t_12);
+
+044: 			b2 = max(u2,ix) - min(l2,ix)

+
      __pyx_t_12 = __pyx_v_ix;
+      __pyx_t_11 = __pyx_v_u2;
+      if (((__pyx_t_12 > __pyx_t_11) != 0)) {
+        __pyx_t_9 = __pyx_t_12;
       } else {
-        __pyx_t_10 = __pyx_t_13;
+        __pyx_t_9 = __pyx_t_11;
       }
-      __pyx_t_14 = __pyx_v_ix;
-      __pyx_t_13 = __pyx_v_l2;
-      if (((__pyx_t_14 < __pyx_t_13) != 0)) {
-        __pyx_t_12 = __pyx_t_14;
+      __pyx_t_12 = __pyx_v_ix;
+      __pyx_t_11 = __pyx_v_l2;
+      if (((__pyx_t_12 < __pyx_t_11) != 0)) {
+        __pyx_t_10 = __pyx_t_12;
       } else {
-        __pyx_t_12 = __pyx_t_13;
+        __pyx_t_10 = __pyx_t_11;
       }
-      __pyx_v_b2 = (__pyx_t_10 - __pyx_t_12);
-
 046: 

-
+047: 			if d <= b1 and d <= b2:

-
      __pyx_t_16 = ((__pyx_v_d <= __pyx_v_b1) != 0);
-      if (__pyx_t_16) {
+      __pyx_v_b2 = (__pyx_t_9 - __pyx_t_10);
+
 045: 

+
+046: 			if d <= b1 and d <= b2:

+
      __pyx_t_14 = ((__pyx_v_d <= __pyx_v_b1) != 0);
+      if (__pyx_t_14) {
       } else {
-        __pyx_t_15 = __pyx_t_16;
+        __pyx_t_13 = __pyx_t_14;
         goto __pyx_L8_bool_binop_done;
       }
-      __pyx_t_16 = ((__pyx_v_d <= __pyx_v_b2) != 0);
-      __pyx_t_15 = __pyx_t_16;
+      __pyx_t_14 = ((__pyx_v_d <= __pyx_v_b2) != 0);
+      __pyx_t_13 = __pyx_t_14;
       __pyx_L8_bool_binop_done:;
-      if (__pyx_t_15) {
+      if (__pyx_t_13) {
 /* … */
       }
-
+048: 				continue

+
+047: 				continue
        goto __pyx_L5_continue;
-
+049: 			elif b1 < d and b1 <= b2:
-
      __pyx_t_16 = ((__pyx_v_b1 < __pyx_v_d) != 0);
-      if (__pyx_t_16) {
+
+048: 			elif b1 < d and b1 <= b2:
+
      __pyx_t_14 = ((__pyx_v_b1 < __pyx_v_d) != 0);
+      if (__pyx_t_14) {
       } else {
-        __pyx_t_15 = __pyx_t_16;
+        __pyx_t_13 = __pyx_t_14;
         goto __pyx_L10_bool_binop_done;
       }
-      __pyx_t_16 = ((__pyx_v_b1 <= __pyx_v_b2) != 0);
-      __pyx_t_15 = __pyx_t_16;
+      __pyx_t_14 = ((__pyx_v_b1 <= __pyx_v_b2) != 0);
+      __pyx_t_13 = __pyx_t_14;
       __pyx_L10_bool_binop_done:;
-      if (__pyx_t_15) {
+      if (__pyx_t_13) {
 /* … */
         goto __pyx_L7;
       }
-
+050: 				D[x][y] = b1
-
        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 50, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 50, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+051: 				U[x][y] = max(u1,ix)
-
        __pyx_t_12 = __pyx_v_ix;
-        __pyx_t_10 = __pyx_v_u1;
-        if (((__pyx_t_12 > __pyx_t_10) != 0)) {
-          __pyx_t_14 = __pyx_t_12;
+
+049: 				D[x,y] = b1
+
        __pyx_t_7 = __pyx_v_x;
+        __pyx_t_8 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_D.diminfo[1].strides) = __pyx_v_b1;
+
+050: 				U[x,y] = max(u1,ix)
+
        __pyx_t_10 = __pyx_v_ix;
+        __pyx_t_9 = __pyx_v_u1;
+        if (((__pyx_t_10 > __pyx_t_9) != 0)) {
+          __pyx_t_12 = __pyx_t_10;
         } else {
-          __pyx_t_14 = __pyx_t_10;
+          __pyx_t_12 = __pyx_t_9;
         }
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 51, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 51, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+052: 				L[x][y] = min(l1,ix)
-
        __pyx_t_14 = __pyx_v_ix;
-        __pyx_t_12 = __pyx_v_l1;
-        if (((__pyx_t_14 < __pyx_t_12) != 0)) {
-          __pyx_t_10 = __pyx_t_14;
+        __pyx_t_8 = __pyx_v_x;
+        __pyx_t_7 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_U.diminfo[1].strides) = __pyx_t_12;
+
+051: 				L[x,y] = min(l1,ix)
+
        __pyx_t_12 = __pyx_v_ix;
+        __pyx_t_10 = __pyx_v_l1;
+        if (((__pyx_t_12 < __pyx_t_10) != 0)) {
+          __pyx_t_9 = __pyx_t_12;
         } else {
-          __pyx_t_10 = __pyx_t_12;
+          __pyx_t_9 = __pyx_t_10;
         }
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 52, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 52, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
 053: 			else:
-
+054: 				D[x][y] = b2
-
      /*else*/ {
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 54, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+055: 				U[x][y] = max(u2,ix)
-
        __pyx_t_10 = __pyx_v_ix;
-        __pyx_t_14 = __pyx_v_u2;
-        if (((__pyx_t_10 > __pyx_t_14) != 0)) {
-          __pyx_t_12 = __pyx_t_10;
+        __pyx_t_7 = __pyx_v_x;
+        __pyx_t_8 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_L.diminfo[1].strides) = __pyx_t_9;
+
 052: 			else:
+
+053: 				D[x,y] = b2
+
      /*else*/ {
+        __pyx_t_8 = __pyx_v_x;
+        __pyx_t_7 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_D.diminfo[1].strides) = __pyx_v_b2;
+
+054: 				U[x,y] = max(u2,ix)
+
        __pyx_t_9 = __pyx_v_ix;
+        __pyx_t_12 = __pyx_v_u2;
+        if (((__pyx_t_9 > __pyx_t_12) != 0)) {
+          __pyx_t_10 = __pyx_t_9;
         } else {
-          __pyx_t_12 = __pyx_t_14;
+          __pyx_t_10 = __pyx_t_12;
         }
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 55, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 55, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+056: 				L[x][y] = min(l2,ix)
-
        __pyx_t_12 = __pyx_v_ix;
-        __pyx_t_10 = __pyx_v_l2;
-        if (((__pyx_t_12 < __pyx_t_10) != 0)) {
-          __pyx_t_14 = __pyx_t_12;
+        __pyx_t_7 = __pyx_v_x;
+        __pyx_t_8 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_8, __pyx_pybuffernd_U.diminfo[1].strides) = __pyx_t_10;
+
+055: 				L[x,y] = min(l2,ix)
+
        __pyx_t_10 = __pyx_v_ix;
+        __pyx_t_9 = __pyx_v_l2;
+        if (((__pyx_t_10 < __pyx_t_9) != 0)) {
+          __pyx_t_12 = __pyx_t_10;
         } else {
-          __pyx_t_14 = __pyx_t_10;
+          __pyx_t_12 = __pyx_t_9;
         }
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_9 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 56, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_9, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 56, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_8 = __pyx_v_x;
+        __pyx_t_7 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_7, __pyx_pybuffernd_L.diminfo[1].strides) = __pyx_t_12;
       }
       __pyx_L7:;
       __pyx_L5_continue:;
     }
   }
-
 057:
-
+058: 	return True
+
 056:
+
+057: 	return True
  __Pyx_XDECREF(__pyx_r);
   __Pyx_INCREF(Py_True);
   __pyx_r = Py_True;
   goto __pyx_L0;
-
 059:
-
 060: @cython.boundscheck(False)
-
+061: cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
-
static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) {
+
 058:
+
 059: @cython.boundscheck(False)
+
 060: @cython.wraparound(False)
+
+061: cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
+
static PyObject *__pyx_f_12saliency_mbd_raster_scan_inv(PyArrayObject *__pyx_v_img, PyArrayObject *__pyx_v_L, PyArrayObject *__pyx_v_U, PyArrayObject *__pyx_v_D) {
   int __pyx_v_n_rows;
   int __pyx_v_n_cols;
-  int __pyx_v_x;
-  int __pyx_v_y;
+  Py_ssize_t __pyx_v_x;
+  Py_ssize_t __pyx_v_y;
   double __pyx_v_ix;
   double __pyx_v_d;
   double __pyx_v_u1;
@@ -819,24 +754,22 @@
   __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1];
   {
     __Pyx_BufFmt_StackElem __pyx_stack[1];
-    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_v_L, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
   }
   __pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1];
   {
     __Pyx_BufFmt_StackElem __pyx_stack[1];
-    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_v_U, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
   }
   __pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1];
   {
     __Pyx_BufFmt_StackElem __pyx_stack[1];
-    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 61, __pyx_L1_error)
   }
   __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1];
 /* … */
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_5);
   { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
     __Pyx_PyThreadState_declare
     __Pyx_PyThreadState_assign
@@ -862,259 +795,214 @@
 
 062: 	cdef int n_rows
 063: 	cdef int n_cols
 064:
-
+065: 	n_rows = len(img)
-
  __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_img)); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 65, __pyx_L1_error)
-  __pyx_v_n_rows = __pyx_t_1;
-
+066: 	n_cols = len(img[0])
-
  __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_n_cols = __pyx_t_1;
+
+065: 	n_rows = img.shape[0]

+
  __pyx_v_n_rows = (__pyx_v_img->dimensions[0]);
+
+066: 	n_cols = img.shape[1]

+
  __pyx_v_n_cols = (__pyx_v_img->dimensions[1]);
 
 067: 

-
 068: 	cdef int x

-
 069: 	cdef int y

-
 070: 	cdef double ix

-
 071: 	cdef double d

-
 072: 	cdef double u1

-
 073: 	cdef double l1

-
 074: 	cdef double u2

-
 075: 	cdef double l2

-
 076: 	cdef double b1

-
 077: 	cdef double b2

-
 078: 

-
+079: 	for x in range(n_rows - 2,1,-1):

-
  for (__pyx_t_3 = (__pyx_v_n_rows - 2); __pyx_t_3 > 1; __pyx_t_3-=1) {
-    __pyx_v_x = __pyx_t_3;
-
+080: 		for y in range(n_cols - 2,1,-1):

-
    for (__pyx_t_4 = (__pyx_v_n_cols - 2); __pyx_t_4 > 1; __pyx_t_4-=1) {
-      __pyx_v_y = __pyx_t_4;
-
 081: 

-
+082: 			ix = img[x][y]

-
      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_img), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_v_ix = __pyx_t_6;
-
+083: 			d = D[x][y]

-
      __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 83, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_v_d = __pyx_t_6;
-
 084: 

-
+085: 			u1 = U[x+1][y]

-
      __pyx_t_7 = (__pyx_v_x + 1);
-      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_v_u1 = __pyx_t_6;
-
+086: 			l1 = L[x+1][y]

-
      __pyx_t_7 = (__pyx_v_x + 1);
-      __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_y, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_v_l1 = __pyx_t_6;
-
 087: 

-
+088: 			u2 = U[x][y+1]

-
      __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_7 = (__pyx_v_y + 1);
-      __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 88, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 88, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_v_u2 = __pyx_t_6;
-
+089: 			l2 = L[x][y+1]

-
      __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_7 = (__pyx_v_y + 1);
-      __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, __pyx_t_7, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_v_l2 = __pyx_t_6;
-
 090: 

-
+091: 			b1 = max(u1,ix) - min(l1,ix)

-
      __pyx_t_6 = __pyx_v_ix;
-      __pyx_t_8 = __pyx_v_u1;
-      if (((__pyx_t_6 > __pyx_t_8) != 0)) {
-        __pyx_t_9 = __pyx_t_6;
+
 068: 	cdef Py_ssize_t x, y

+
 069: 	cdef double ix

+
 070: 	cdef double d

+
 071: 	cdef double u1

+
 072: 	cdef double l1

+
 073: 	cdef double u2

+
 074: 	cdef double l2

+
 075: 	cdef double b1

+
 076: 	cdef double b2

+
 077: 

+
+078: 	for x in xrange(n_rows - 2,1,-1):

+
  for (__pyx_t_1 = (__pyx_v_n_rows - 2); __pyx_t_1 > 1; __pyx_t_1-=1) {
+    __pyx_v_x = __pyx_t_1;
+
+079: 		for y in xrange(n_cols - 2,1,-1):

+
    for (__pyx_t_2 = (__pyx_v_n_cols - 2); __pyx_t_2 > 1; __pyx_t_2-=1) {
+      __pyx_v_y = __pyx_t_2;
+
 080: 

+
+081: 			ix = img[x,y]

+
      __pyx_t_3 = __pyx_v_x;
+      __pyx_t_4 = __pyx_v_y;
+      __pyx_v_ix = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_img.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_img.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_img.diminfo[1].strides));
+
+082: 			d = D[x,y]

+
      __pyx_t_4 = __pyx_v_x;
+      __pyx_t_3 = __pyx_v_y;
+      __pyx_v_d = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_D.diminfo[1].strides));
+
 083: 

+
+084: 			u1 = U[x+1,y]

+
      __pyx_t_3 = (__pyx_v_x + 1);
+      __pyx_t_4 = __pyx_v_y;
+      __pyx_v_u1 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_U.diminfo[1].strides));
+
+085: 			l1 = L[x+1,y]

+
      __pyx_t_4 = (__pyx_v_x + 1);
+      __pyx_t_3 = __pyx_v_y;
+      __pyx_v_l1 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_L.diminfo[1].strides));
+
 086: 

+
+087: 			u2 = U[x,y+1]

+
      __pyx_t_3 = __pyx_v_x;
+      __pyx_t_4 = (__pyx_v_y + 1);
+      __pyx_v_u2 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_U.diminfo[1].strides));
+
+088: 			l2 = L[x,y+1]

+
      __pyx_t_4 = __pyx_v_x;
+      __pyx_t_3 = (__pyx_v_y + 1);
+      __pyx_v_l2 = (*__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_L.diminfo[1].strides));
+
 089: 

+
+090: 			b1 = max(u1,ix) - min(l1,ix)

+
      __pyx_t_5 = __pyx_v_ix;
+      __pyx_t_6 = __pyx_v_u1;
+      if (((__pyx_t_5 > __pyx_t_6) != 0)) {
+        __pyx_t_7 = __pyx_t_5;
       } else {
-        __pyx_t_9 = __pyx_t_8;
+        __pyx_t_7 = __pyx_t_6;
       }
-      __pyx_t_6 = __pyx_v_ix;
-      __pyx_t_8 = __pyx_v_l1;
-      if (((__pyx_t_6 < __pyx_t_8) != 0)) {
-        __pyx_t_10 = __pyx_t_6;
+      __pyx_t_5 = __pyx_v_ix;
+      __pyx_t_6 = __pyx_v_l1;
+      if (((__pyx_t_5 < __pyx_t_6) != 0)) {
+        __pyx_t_8 = __pyx_t_5;
       } else {
-        __pyx_t_10 = __pyx_t_8;
+        __pyx_t_8 = __pyx_t_6;
       }
-      __pyx_v_b1 = (__pyx_t_9 - __pyx_t_10);
-
+092: 			b2 = max(u2,ix) - min(l2,ix)

-
      __pyx_t_10 = __pyx_v_ix;
-      __pyx_t_9 = __pyx_v_u2;
-      if (((__pyx_t_10 > __pyx_t_9) != 0)) {
-        __pyx_t_6 = __pyx_t_10;
+      __pyx_v_b1 = (__pyx_t_7 - __pyx_t_8);
+
+091: 			b2 = max(u2,ix) - min(l2,ix)

+
      __pyx_t_8 = __pyx_v_ix;
+      __pyx_t_7 = __pyx_v_u2;
+      if (((__pyx_t_8 > __pyx_t_7) != 0)) {
+        __pyx_t_5 = __pyx_t_8;
       } else {
-        __pyx_t_6 = __pyx_t_9;
+        __pyx_t_5 = __pyx_t_7;
       }
-      __pyx_t_10 = __pyx_v_ix;
-      __pyx_t_9 = __pyx_v_l2;
-      if (((__pyx_t_10 < __pyx_t_9) != 0)) {
-        __pyx_t_8 = __pyx_t_10;
+      __pyx_t_8 = __pyx_v_ix;
+      __pyx_t_7 = __pyx_v_l2;
+      if (((__pyx_t_8 < __pyx_t_7) != 0)) {
+        __pyx_t_6 = __pyx_t_8;
       } else {
-        __pyx_t_8 = __pyx_t_9;
+        __pyx_t_6 = __pyx_t_7;
       }
-      __pyx_v_b2 = (__pyx_t_6 - __pyx_t_8);
-
 093: 

-
+094: 			if d <= b1 and d <= b2:

-
      __pyx_t_12 = ((__pyx_v_d <= __pyx_v_b1) != 0);
-      if (__pyx_t_12) {
+      __pyx_v_b2 = (__pyx_t_5 - __pyx_t_6);
+
 092: 

+
+093: 			if d <= b1 and d <= b2:

+
      __pyx_t_10 = ((__pyx_v_d <= __pyx_v_b1) != 0);
+      if (__pyx_t_10) {
       } else {
-        __pyx_t_11 = __pyx_t_12;
+        __pyx_t_9 = __pyx_t_10;
         goto __pyx_L8_bool_binop_done;
       }
-      __pyx_t_12 = ((__pyx_v_d <= __pyx_v_b2) != 0);
-      __pyx_t_11 = __pyx_t_12;
+      __pyx_t_10 = ((__pyx_v_d <= __pyx_v_b2) != 0);
+      __pyx_t_9 = __pyx_t_10;
       __pyx_L8_bool_binop_done:;
-      if (__pyx_t_11) {
+      if (__pyx_t_9) {
 /* … */
       }
-
+095: 				continue

+
+094: 				continue

 
        goto __pyx_L5_continue;
-
+096: 			elif b1 < d and b1 <= b2:

-
      __pyx_t_12 = ((__pyx_v_b1 < __pyx_v_d) != 0);
-      if (__pyx_t_12) {
+
+095: 			elif b1 < d and b1 <= b2:

+
      __pyx_t_10 = ((__pyx_v_b1 < __pyx_v_d) != 0);
+      if (__pyx_t_10) {
       } else {
-        __pyx_t_11 = __pyx_t_12;
+        __pyx_t_9 = __pyx_t_10;
         goto __pyx_L10_bool_binop_done;
       }
-      __pyx_t_12 = ((__pyx_v_b1 <= __pyx_v_b2) != 0);
-      __pyx_t_11 = __pyx_t_12;
+      __pyx_t_10 = ((__pyx_v_b1 <= __pyx_v_b2) != 0);
+      __pyx_t_9 = __pyx_t_10;
       __pyx_L10_bool_binop_done:;
-      if (__pyx_t_11) {
+      if (__pyx_t_9) {
 /* … */
         goto __pyx_L7;
       }
-
+097: 				D[x][y] = b1

-
        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 97, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+098: 				U[x][y] = max(u1,ix)

-
        __pyx_t_8 = __pyx_v_ix;
-        __pyx_t_6 = __pyx_v_u1;
-        if (((__pyx_t_8 > __pyx_t_6) != 0)) {
-          __pyx_t_10 = __pyx_t_8;
+
+096: 				D[x,y] = b1

+
        __pyx_t_3 = __pyx_v_x;
+        __pyx_t_4 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_D.diminfo[1].strides) = __pyx_v_b1;
+
+097: 				U[x,y] = max(u1,ix)

+
        __pyx_t_6 = __pyx_v_ix;
+        __pyx_t_5 = __pyx_v_u1;
+        if (((__pyx_t_6 > __pyx_t_5) != 0)) {
+          __pyx_t_8 = __pyx_t_6;
+        } else {
+          __pyx_t_8 = __pyx_t_5;
+        }
+        __pyx_t_4 = __pyx_v_x;
+        __pyx_t_3 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_U.diminfo[1].strides) = __pyx_t_8;
+
+098: 				L[x,y] = min(l1,ix)

+
        __pyx_t_8 = __pyx_v_ix;
+        __pyx_t_6 = __pyx_v_l1;
+        if (((__pyx_t_8 < __pyx_t_6) != 0)) {
+          __pyx_t_5 = __pyx_t_8;
         } else {
-          __pyx_t_10 = __pyx_t_6;
+          __pyx_t_5 = __pyx_t_6;
         }
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 98, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 98, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+099: 				L[x][y] = min(l1,ix)

-
        __pyx_t_10 = __pyx_v_ix;
-        __pyx_t_8 = __pyx_v_l1;
-        if (((__pyx_t_10 < __pyx_t_8) != 0)) {
-          __pyx_t_6 = __pyx_t_10;
+        __pyx_t_3 = __pyx_v_x;
+        __pyx_t_4 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_L.diminfo[1].strides) = __pyx_t_5;
+
 099: 			else:

+
+100: 				D[x,y] = b2

+
      /*else*/ {
+        __pyx_t_4 = __pyx_v_x;
+        __pyx_t_3 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_D.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_D.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_D.diminfo[1].strides) = __pyx_v_b2;
+
+101: 				U[x,y] = max(u2,ix)

+
        __pyx_t_5 = __pyx_v_ix;
+        __pyx_t_8 = __pyx_v_u2;
+        if (((__pyx_t_5 > __pyx_t_8) != 0)) {
+          __pyx_t_6 = __pyx_t_5;
         } else {
           __pyx_t_6 = __pyx_t_8;
         }
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 99, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
 100: 			else:

-
+101: 				D[x][y] = b2

-
      /*else*/ {
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_v_b2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_D), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 101, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+102: 				U[x][y] = max(u2,ix)

-
        __pyx_t_6 = __pyx_v_ix;
-        __pyx_t_10 = __pyx_v_u2;
-        if (((__pyx_t_6 > __pyx_t_10) != 0)) {
+        __pyx_t_3 = __pyx_v_x;
+        __pyx_t_4 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_U.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_U.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_U.diminfo[1].strides) = __pyx_t_6;
+
+102: 				L[x,y] = min(l2,ix)

+
        __pyx_t_6 = __pyx_v_ix;
+        __pyx_t_5 = __pyx_v_l2;
+        if (((__pyx_t_6 < __pyx_t_5) != 0)) {
           __pyx_t_8 = __pyx_t_6;
         } else {
-          __pyx_t_8 = __pyx_t_10;
-        }
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_U), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 102, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+103: 				L[x][y] = min(l2,ix)

-
        __pyx_t_8 = __pyx_v_ix;
-        __pyx_t_6 = __pyx_v_l2;
-        if (((__pyx_t_8 < __pyx_t_6) != 0)) {
-          __pyx_t_10 = __pyx_t_8;
-        } else {
-          __pyx_t_10 = __pyx_t_6;
+          __pyx_t_8 = __pyx_t_5;
         }
-        __pyx_t_2 = PyFloat_FromDouble(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_5 = __Pyx_GetItemInt(((PyObject *)__pyx_v_L), __pyx_v_x, int, 1, __Pyx_PyInt_From_int, 0, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 103, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        if (unlikely(__Pyx_SetItemInt(__pyx_t_5, __pyx_v_y, __pyx_t_2, int, 1, __Pyx_PyInt_From_int, 0, 1, 0) < 0)) __PYX_ERR(0, 103, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_4 = __pyx_v_x;
+        __pyx_t_3 = __pyx_v_y;
+        *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_L.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_L.diminfo[0].strides, __pyx_t_3, __pyx_pybuffernd_L.diminfo[1].strides) = __pyx_t_8;
       }
       __pyx_L7:;
       __pyx_L5_continue:;
     }
   }
-
 104: 

-
+105: 	return True

+
 103:
+
+104: 	return True
  __Pyx_XDECREF(__pyx_r);
   __Pyx_INCREF(Py_True);
   __pyx_r = Py_True;
   goto __pyx_L0;
-
 106:
-
 107: @cython.boundscheck(False)
-
+108: cdef mbd(np.ndarray[double, ndim=2] img, int num_iters):
-
static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __pyx_v_num_iters) {
-  PyObject *__pyx_v_L = NULL;
-  PyObject *__pyx_v_U = NULL;
-  PyObject *__pyx_v_D = NULL;
+
 105:
+
 106: @cython.boundscheck(False)
+
 107: @cython.wraparound(False)
+
+108: cdef mbd(np.ndarray[double, ndim=2] img, int num_iters):
+
static PyObject *__pyx_f_12saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __pyx_v_num_iters) {
+  PyArrayObject *__pyx_v_L = 0;
+  PyArrayObject *__pyx_v_U = 0;
+  PyArrayObject *__pyx_v_D = 0;
   int __pyx_v_x;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_D;
+  __Pyx_Buffer __pyx_pybuffer_D;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_L;
+  __Pyx_Buffer __pyx_pybuffer_L;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_U;
+  __Pyx_Buffer __pyx_pybuffer_U;
   __Pyx_LocalBuf_ND __pyx_pybuffernd_img;
   __Pyx_Buffer __pyx_pybuffer_img;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("mbd", 0);
+  __pyx_pybuffer_L.pybuffer.buf = NULL;
+  __pyx_pybuffer_L.refcount = 0;
+  __pyx_pybuffernd_L.data = NULL;
+  __pyx_pybuffernd_L.rcbuffer = &__pyx_pybuffer_L;
+  __pyx_pybuffer_U.pybuffer.buf = NULL;
+  __pyx_pybuffer_U.refcount = 0;
+  __pyx_pybuffernd_U.data = NULL;
+  __pyx_pybuffernd_U.rcbuffer = &__pyx_pybuffer_U;
+  __pyx_pybuffer_D.pybuffer.buf = NULL;
+  __pyx_pybuffer_D.refcount = 0;
+  __pyx_pybuffernd_D.data = NULL;
+  __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D;
   __pyx_pybuffer_img.pybuffer.buf = NULL;
   __pyx_pybuffer_img.refcount = 0;
   __pyx_pybuffernd_img.data = NULL;
@@ -1130,29 +1018,35 @@
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
   { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
     __Pyx_PyThreadState_declare
     __Pyx_PyThreadState_assign
     __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer);
     __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
   __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
   __Pyx_AddTraceback("saliency_mbd.mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = 0;
   goto __pyx_L2;
   __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_L.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_U.rcbuffer->pybuffer);
   __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
   __pyx_L2:;
-  __Pyx_XDECREF(__pyx_v_L);
-  __Pyx_XDECREF(__pyx_v_U);
-  __Pyx_XDECREF(__pyx_v_D);
+  __Pyx_XDECREF((PyObject *)__pyx_v_L);
+  __Pyx_XDECREF((PyObject *)__pyx_v_U);
+  __Pyx_XDECREF((PyObject *)__pyx_v_D);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 109:
-
+110: 	L = np.copy(img)
-
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
+
+110: 	cdef np.ndarray[double, ndim=2] L = np.copy(img)

+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
@@ -1172,10 +1066,21 @@
   if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_v_L = __pyx_t_1;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 110, __pyx_L1_error)
+  __pyx_t_4 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_L.rcbuffer->pybuffer, (PyObject*)__pyx_t_4, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_L = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_L.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 110, __pyx_L1_error)
+    } else {__pyx_pybuffernd_L.diminfo[0].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_L.diminfo[0].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_L.diminfo[1].strides = __pyx_pybuffernd_L.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_L.diminfo[1].shape = __pyx_pybuffernd_L.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_4 = 0;
+  __pyx_v_L = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
-
+111: 	U = np.copy(img)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
+
+111: 	cdef np.ndarray[double, ndim=2] U = np.copy(img)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
@@ -1195,16 +1100,27 @@
   if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_U = __pyx_t_1;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 111, __pyx_L1_error)
+  __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_U.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_U = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_U.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 111, __pyx_L1_error)
+    } else {__pyx_pybuffernd_U.diminfo[0].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_U.diminfo[0].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_U.diminfo[1].strides = __pyx_pybuffernd_U.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_U.diminfo[1].shape = __pyx_pybuffernd_U.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_5 = 0;
+  __pyx_v_U = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
-
+112: 	D = np.full_like(img, 10000000)

-
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error)
+
+112: 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)

+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_full_like); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_t_2 = NULL;
-  __pyx_t_4 = 0;
+  __pyx_t_6 = 0;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
     __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
     if (likely(__pyx_t_2)) {
@@ -1212,13 +1128,13 @@
       __Pyx_INCREF(__pyx_t_2);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_3, function);
-      __pyx_t_4 = 1;
+      __pyx_t_6 = 1;
     }
   }
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_3)) {
     PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_img), __pyx_int_10000000};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_GOTREF(__pyx_t_1);
   } else
@@ -1226,83 +1142,88 @@
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
     PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)__pyx_v_img), __pyx_int_10000000};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_GOTREF(__pyx_t_1);
   } else
   #endif
   {
-    __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
     if (__pyx_t_2) {
-      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL;
     }
     __Pyx_INCREF(((PyObject *)__pyx_v_img));
     __Pyx_GIVEREF(((PyObject *)__pyx_v_img));
-    PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, ((PyObject *)__pyx_v_img));
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, ((PyObject *)__pyx_v_img));
     __Pyx_INCREF(__pyx_int_10000000);
     __Pyx_GIVEREF(__pyx_int_10000000);
-    PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_int_10000000);
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_10000000);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
   }
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_v_D = __pyx_t_1;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 112, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_D = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_D.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 112, __pyx_L1_error)
+    } else {__pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_D = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
+113: 	D[0,:] = 0

 
  __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_slice_);
   __Pyx_GIVEREF(__pyx_slice_);
 /* … */
-  if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__2, __pyx_int_0) < 0)) __PYX_ERR(0, 113, __pyx_L1_error)
+  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__2, __pyx_int_0) < 0)) __PYX_ERR(0, 113, __pyx_L1_error)
   __pyx_tuple__2 = PyTuple_Pack(2, __pyx_int_0, __pyx_slice_); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__2);
   __Pyx_GIVEREF(__pyx_tuple__2);
 
+114: 	D[-1,:] = 0

-
  if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__3, __pyx_int_0) < 0)) __PYX_ERR(0, 114, __pyx_L1_error)
+
  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__3, __pyx_int_0) < 0)) __PYX_ERR(0, 114, __pyx_L1_error)
 /* … */
   __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_neg_1, __pyx_slice_); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 114, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__3);
   __Pyx_GIVEREF(__pyx_tuple__3);
 
+115: 	D[:,0] = 0

-
  if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__4, __pyx_int_0) < 0)) __PYX_ERR(0, 115, __pyx_L1_error)
+
  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__4, __pyx_int_0) < 0)) __PYX_ERR(0, 115, __pyx_L1_error)
 /* … */
   __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__4);
   __Pyx_GIVEREF(__pyx_tuple__4);
 
+116: 	D[:,-1] = 0

-
  if (unlikely(PyObject_SetItem(__pyx_v_D, __pyx_tuple__5, __pyx_int_0) < 0)) __PYX_ERR(0, 116, __pyx_L1_error)
+
  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__5, __pyx_int_0) < 0)) __PYX_ERR(0, 116, __pyx_L1_error)
 /* … */
   __pyx_tuple__5 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__5);
   __Pyx_GIVEREF(__pyx_tuple__5);
 
 117: 

 
 118: 	cdef int x

-
+119: 	for x in range(0,num_iters):

-
  __pyx_t_4 = __pyx_v_num_iters;
-  __pyx_t_6 = __pyx_t_4;
-  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
-    __pyx_v_x = __pyx_t_7;
+
+119: 	for x in xrange(0,num_iters):

+
  __pyx_t_6 = __pyx_v_num_iters;
+  __pyx_t_9 = __pyx_t_6;
+  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
+    __pyx_v_x = __pyx_t_10;
 
+120: 		if x%2 == 1:

-
    __pyx_t_8 = ((__Pyx_mod_long(__pyx_v_x, 2) == 1) != 0);
-    if (__pyx_t_8) {
+
    __pyx_t_11 = ((__Pyx_mod_long(__pyx_v_x, 2) == 1) != 0);
+    if (__pyx_t_11) {
 /* … */
       goto __pyx_L5;
     }
-
+121: 			raster_scan(img,L,U,D)

-
      if (!(likely(((__pyx_v_L) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_L, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error)
-      if (!(likely(((__pyx_v_U) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_U, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error)
-      if (!(likely(((__pyx_v_D) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_D, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 121, __pyx_L1_error)
-      __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error)
+
+121: 			raster_scan(img,L,U,D)

+
      __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
 122: 		else:

-
+123: 			raster_scan_inv(img,L,U,D)

-
    /*else*/ {
-      if (!(likely(((__pyx_v_L) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_L, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error)
-      if (!(likely(((__pyx_v_U) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_U, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error)
-      if (!(likely(((__pyx_v_D) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_D, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error)
+
+123: 			raster_scan_inv(img,L,U,D)

+
    /*else*/ {
       __pyx_t_1 = __pyx_f_12saliency_mbd_raster_scan_inv(((PyArrayObject *)__pyx_v_img), ((PyArrayObject *)__pyx_v_L), ((PyArrayObject *)__pyx_v_U), ((PyArrayObject *)__pyx_v_D)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -1312,26 +1233,12 @@
 
 124: 

 
+125: 	return D

 
  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_D);
-  __pyx_r = __pyx_v_D;
+  __Pyx_INCREF(((PyObject *)__pyx_v_D));
+  __pyx_r = ((PyObject *)__pyx_v_D);
   goto __pyx_L0;
 
 126: 

-
+127: def f(x):

-
/* Python wrapper */
-static PyObject *__pyx_pw_12saliency_mbd_1f(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/
-static PyMethodDef __pyx_mdef_12saliency_mbd_1f = {"f", (PyCFunction)__pyx_pw_12saliency_mbd_1f, METH_O, 0};
-static PyObject *__pyx_pw_12saliency_mbd_1f(PyObject *__pyx_self, PyObject *__pyx_v_x) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("f (wrapper)", 0);
-  __pyx_r = __pyx_pf_12saliency_mbd_f(__pyx_self, ((PyObject *)__pyx_v_x));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_12saliency_mbd_f(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) {
+
+127: cdef f(x):

+
static PyObject *__pyx_f_12saliency_mbd_f(PyObject *__pyx_v_x) {
   double __pyx_v_b;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
@@ -1343,21 +1250,12 @@
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_AddTraceback("saliency_mbd.f", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __pyx_r = 0;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
-/* … */
-  __pyx_tuple__15 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_b); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 127, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__15);
-  __Pyx_GIVEREF(__pyx_tuple__15);
-/* … */
-  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_12saliency_mbd_1f, NULL, __pyx_n_s_saliency_mbd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_f, __pyx_t_1) < 0) __PYX_ERR(0, 127, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+128: 	b = 10.0

 
  __pyx_v_b = 10.0;
 
+129: 	return 1.0 / (1.0 + exp(-b*(x - 0.5)))

@@ -1384,8 +1282,9 @@
   goto __pyx_L0;
 
 130: 

 
 131: @cython.boundscheck(False)

-
+132: cpdef get_saliency_mbd(np.ndarray img,method='b'):

-
static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+
 132: @cython.wraparound(False)

+
+133: cpdef get_saliency_mbd(np.ndarray img,method='b'):

+
static PyObject *__pyx_pw_12saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static PyObject *__pyx_f_12saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_img, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd *__pyx_optional_args) {
   PyObject *__pyx_v_img_mean = NULL;
   PyObject *__pyx_v_sal = NULL;
@@ -1429,8 +1328,8 @@
   CYTHON_UNUSED double __pyx_v_delta;
   PyObject *__pyx_v_xv = NULL;
   PyObject *__pyx_v_yv = NULL;
-  PyObject *__pyx_v_w = NULL;
-  PyObject *__pyx_v_h = NULL;
+  int __pyx_v_w;
+  int __pyx_v_h;
   double __pyx_v_w2;
   double __pyx_v_h2;
   PyObject *__pyx_v_C = NULL;
@@ -1490,8 +1389,6 @@
   __Pyx_XDECREF(__pyx_v_s);
   __Pyx_XDECREF(__pyx_v_xv);
   __Pyx_XDECREF(__pyx_v_yv);
-  __Pyx_XDECREF(__pyx_v_w);
-  __Pyx_XDECREF(__pyx_v_h);
   __Pyx_XDECREF(__pyx_v_C);
   __Pyx_XDECREF(__pyx_v_fv);
   __Pyx_XGIVEREF(__pyx_r);
@@ -1500,8 +1397,8 @@
 }
 
 /* Python wrapper */
-static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyObject *__pyx_pw_12saliency_mbd_3get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_12saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyObject *__pyx_pw_12saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyArrayObject *__pyx_v_img = 0;
   PyObject *__pyx_v_method = 0;
   PyObject *__pyx_r = 0;
@@ -1535,7 +1432,7 @@
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 132, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 133, __pyx_L3_error)
       }
     } else {
       switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -1551,14 +1448,14 @@
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 132, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 133, __pyx_L3_error)
   __pyx_L3_error:;
   __Pyx_AddTraceback("saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 132, __pyx_L1_error)
-  __pyx_r = __pyx_pf_12saliency_mbd_2get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 133, __pyx_L1_error)
+  __pyx_r = __pyx_pf_12saliency_mbd_get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method);
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -1572,14 +1469,14 @@
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_12saliency_mbd_2get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method) {
+static PyObject *__pyx_pf_12saliency_mbd_get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get_saliency_mbd", 0);
   __Pyx_XDECREF(__pyx_r);
   __pyx_t_2.__pyx_n = 1;
   __pyx_t_2.method = __pyx_v_method;
-  __pyx_t_1 = __pyx_f_12saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_12saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -1595,58 +1492,63 @@
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
-
 133: 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS

-
+134: 	img_mean = np.mean(img,axis=(2))

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
+/* … */
+struct __pyx_opt_args_12saliency_mbd_get_saliency_mbd {
+  int __pyx_n;
+  PyObject *method;
+};
+
 134: 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS

+
+135: 	img_mean = np.mean(img,axis=(2))

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_INCREF(((PyObject *)__pyx_v_img));
   __Pyx_GIVEREF(((PyObject *)__pyx_v_img));
   PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_img));
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_int_2) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
-  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_int_2) < 0) __PYX_ERR(0, 135, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_img_mean = __pyx_t_4;
   __pyx_t_4 = 0;
-
+135: 	sal = mbd(img_mean,2)

-
  if (!(likely(((__pyx_v_img_mean) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_img_mean, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 135, __pyx_L1_error)
-  __pyx_t_4 = __pyx_f_12saliency_mbd_mbd(((PyArrayObject *)__pyx_v_img_mean), 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error)
+
+136: 	sal = mbd(img_mean,2)

+
  if (!(likely(((__pyx_v_img_mean) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_img_mean, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 136, __pyx_L1_error)
+  __pyx_t_4 = __pyx_f_12saliency_mbd_mbd(((PyArrayObject *)__pyx_v_img_mean), 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __pyx_v_sal = __pyx_t_4;
   __pyx_t_4 = 0;
-
 136: 

-
+137: 	cdef int n_rows = img.shape[0]

+
 137: 

+
+138: 	cdef int n_rows = img.shape[0]

 
  __pyx_v_n_rows = (__pyx_v_img->dimensions[0]);
-
+138: 	cdef int n_cols = img.shape[1]

+
+139: 	cdef int n_cols = img.shape[1]

 
  __pyx_v_n_cols = (__pyx_v_img->dimensions[1]);
-
+139: 	cdef int n_channels = img.shape[2]

+
+140: 	cdef int n_channels = img.shape[2]

 
  __pyx_v_n_channels = (__pyx_v_img->dimensions[2]);
-
+140: 	cdef double img_size = sqrt(n_rows * n_cols)

+
+141: 	cdef double img_size = sqrt(n_rows * n_cols)

 
  __pyx_v_img_size = sqrt((__pyx_v_n_rows * __pyx_v_n_cols));
-
+141: 	border_thickness = int(floor(0.1 * img_size))

-
  __pyx_t_4 = __Pyx_PyInt_FromDouble(floor((0.1 * __pyx_v_img_size))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error)
+
+142: 	border_thickness = int(floor(0.1 * img_size))

+
  __pyx_t_4 = __Pyx_PyInt_FromDouble(floor((0.1 * __pyx_v_img_size))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __pyx_v_border_thickness = __pyx_t_4;
   __pyx_t_4 = 0;
-
 142: 

-
+143: 	cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img))

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
+
 143: 

+
+144: 	cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img))

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 144, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_skimage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_skimage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_color); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_color); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 144, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_rgb2lab); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_rgb2lab); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_t_5 = NULL;
@@ -1661,7 +1563,7 @@
   }
   __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_img));
   __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_t_2 = NULL;
@@ -1677,17 +1579,17 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 143, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 144, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 143, __pyx_L1_error)
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 144, __pyx_L1_error)
   __pyx_v_img_lab = ((PyArrayObject *)__pyx_t_4);
   __pyx_t_4 = 0;
-
 144: 

-
+145: 	px_left = img_lab[0:border_thickness,:,:]

-
  __pyx_t_4 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error)
+
 145: 

+
+146: 	px_left = img_lab[0:border_thickness,:,:]

+
  __pyx_t_4 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_4);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
@@ -1698,24 +1600,24 @@
   __Pyx_GIVEREF(__pyx_slice_);
   PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_);
   __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_px_left = __pyx_t_4;
   __pyx_t_4 = 0;
-
+146: 	px_right = img_lab[n_rows - border_thickness-1:-1,:,:]

-
  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+
+147: 	px_right = img_lab[n_rows - border_thickness-1:-1,:,:]

+
  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_v_border_thickness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_v_border_thickness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PySlice_New(__pyx_t_4, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __pyx_t_3 = PySlice_New(__pyx_t_4, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_GIVEREF(__pyx_t_3);
   PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
@@ -1726,16 +1628,16 @@
   __Pyx_GIVEREF(__pyx_slice_);
   PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_);
   __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_v_px_right = __pyx_t_3;
   __pyx_t_3 = 0;
-
 147: 

-
+148: 	px_top = img_lab[:,0:border_thickness,:]

-
  __pyx_t_3 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error)
+
 148: 

+
+149: 	px_top = img_lab[:,0:border_thickness,:]

+
  __pyx_t_3 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_INCREF(__pyx_slice_);
   __Pyx_GIVEREF(__pyx_slice_);
@@ -1746,24 +1648,24 @@
   __Pyx_GIVEREF(__pyx_slice_);
   PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_);
   __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_v_px_top = __pyx_t_3;
   __pyx_t_3 = 0;
-
+149: 	px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:]

-
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
+
+150: 	px_bottom = img_lab[:,n_cols - border_thickness-1:-1,:]

+
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_v_border_thickness); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_v_border_thickness); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PySlice_New(__pyx_t_3, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __pyx_t_4 = PySlice_New(__pyx_t_3, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_INCREF(__pyx_slice_);
   __Pyx_GIVEREF(__pyx_slice_);
@@ -1774,27 +1676,27 @@
   __Pyx_GIVEREF(__pyx_slice_);
   PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_slice_);
   __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_px_bottom = __pyx_t_4;
   __pyx_t_4 = 0;
-
 150: 

-
+151: 	px_mean_left = np.mean(px_left,axis=(0,1))

-
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+
 151: 

+
+152: 	px_mean_left = np.mean(px_left,axis=(0,1))

+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_INCREF(__pyx_v_px_left);
   __Pyx_GIVEREF(__pyx_v_px_left);
   PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_px_left);
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 151, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 152, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -1802,83 +1704,83 @@
   __pyx_v_px_mean_left = __pyx_t_2;
   __pyx_t_2 = 0;
 /* … */
-  __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__6);
   __Pyx_GIVEREF(__pyx_tuple__6);
-
+152: 	px_mean_right = np.mean(px_right,axis=(0,1))

-
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
+
+153: 	px_mean_right = np.mean(px_right,axis=(0,1))

+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_INCREF(__pyx_v_px_right);
   __Pyx_GIVEREF(__pyx_v_px_right);
   PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_px_right);
-  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 152, __pyx_L1_error)
-  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 153, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_v_px_mean_right = __pyx_t_3;
   __pyx_t_3 = 0;
-
+153: 	px_mean_top = np.mean(px_top,axis=(0,1))

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
+
+154: 	px_mean_top = np.mean(px_top,axis=(0,1))

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_INCREF(__pyx_v_px_top);
   __Pyx_GIVEREF(__pyx_v_px_top);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_px_top);
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 153, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 154, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_v_px_mean_top = __pyx_t_1;
   __pyx_t_1 = 0;
-
+154: 	px_mean_bottom = np.mean(px_bottom,axis=(0,1))

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
+
+155: 	px_mean_bottom = np.mean(px_bottom,axis=(0,1))

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_INCREF(__pyx_v_px_bottom);
   __Pyx_GIVEREF(__pyx_v_px_bottom);
   PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_px_bottom);
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 155, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 154, __pyx_L1_error)
-  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_px_mean_bottom = __pyx_t_4;
   __pyx_t_4 = 0;
-
 155: 

-
 156: 

-
+157: 	px_left = px_left.reshape((n_cols*border_thickness,3))

-
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error)
+
 156: 

+
 157: 

+
+158: 	px_left = px_left.reshape((n_cols*border_thickness,3))

+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_2);
   PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
@@ -1899,20 +1801,20 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF_SET(__pyx_v_px_left, __pyx_t_4);
   __pyx_t_4 = 0;
-
+158: 	px_right = px_right.reshape((n_cols*border_thickness,3))

-
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error)
+
+159: 	px_right = px_right.reshape((n_cols*border_thickness,3))

+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 159, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 159, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_2);
   PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
@@ -1933,21 +1835,21 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF_SET(__pyx_v_px_right, __pyx_t_4);
   __pyx_t_4 = 0;
-
 159: 

-
+160: 	px_top = px_top.reshape((n_rows*border_thickness,3))

-
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
+
 160: 

+
+161: 	px_top = px_top.reshape((n_rows*border_thickness,3))

+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_2);
   PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
@@ -1968,20 +1870,20 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF_SET(__pyx_v_px_top, __pyx_t_4);
   __pyx_t_4 = 0;
-
+161: 	px_bottom = px_bottom.reshape((n_rows*border_thickness,3))

-
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error)
+
+162: 	px_bottom = px_bottom.reshape((n_rows*border_thickness,3))

+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_2);
   PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
@@ -2002,19 +1904,19 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF_SET(__pyx_v_px_bottom, __pyx_t_4);
   __pyx_t_4 = 0;
-
 162: 

-
+163: 	cov_left = np.cov(px_left.T)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error)
+
 163: 

+
+164: 	cov_left = np.cov(px_left.T)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_left, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -2029,18 +1931,18 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_cov_left = __pyx_t_4;
   __pyx_t_4 = 0;
-
+164: 	cov_right = np.cov(px_right.T)

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
+
+165: 	cov_right = np.cov(px_right.T)

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_right, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
@@ -2055,19 +1957,19 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_cov_right = __pyx_t_4;
   __pyx_t_4 = 0;
-
 165: 

-
+166: 	cov_top = np.cov(px_top.T)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error)
+
 166: 

+
+167: 	cov_top = np.cov(px_top.T)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_top, __pyx_n_s_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -2082,18 +1984,18 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_cov_top = __pyx_t_4;
   __pyx_t_4 = 0;
-
+167: 	cov_bottom = np.cov(px_bottom.T)

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
+
+168: 	cov_bottom = np.cov(px_bottom.T)

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 167, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_px_bottom, __pyx_n_s_T); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
@@ -2108,19 +2010,19 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_cov_bottom = __pyx_t_4;
   __pyx_t_4 = 0;
-
 168: 

-
+169: 	cov_left = np.linalg.inv(cov_left)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error)
+
 169: 

+
+170: 	cov_left = np.linalg.inv(cov_left)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2135,18 +2037,18 @@
   }
   __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_left) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_left);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 169, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF_SET(__pyx_v_cov_left, __pyx_t_4);
   __pyx_t_4 = 0;
-
+170: 	cov_right = np.linalg.inv(cov_right)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
+
+171: 	cov_right = np.linalg.inv(cov_right)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2161,19 +2063,19 @@
   }
   __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_right) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_right);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF_SET(__pyx_v_cov_right, __pyx_t_4);
   __pyx_t_4 = 0;
-
 171: 

-
+172: 	cov_top = np.linalg.inv(cov_top)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error)
+
 172: 

+
+173: 	cov_top = np.linalg.inv(cov_top)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2188,18 +2090,18 @@
   }
   __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_top) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_top);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 173, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF_SET(__pyx_v_cov_top, __pyx_t_4);
   __pyx_t_4 = 0;
-
+173: 	cov_bottom = np.linalg.inv(cov_bottom)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error)
+
+174: 	cov_bottom = np.linalg.inv(cov_bottom)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 174, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2214,20 +2116,20 @@
   }
   __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_cov_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_cov_bottom);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 173, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 174, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF_SET(__pyx_v_cov_bottom, __pyx_t_4);
   __pyx_t_4 = 0;
-
 174: 

-
 175: 

-
+176: 	u_left = np.zeros(sal.shape)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error)
+
 175: 

+
 176: 

+
+177: 	u_left = np.zeros(sal.shape)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -2242,18 +2144,18 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 176, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_u_left = __pyx_t_4;
   __pyx_t_4 = 0;
-
+177: 	u_right = np.zeros(sal.shape)

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
+
+178: 	u_right = np.zeros(sal.shape)

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
@@ -2268,18 +2170,18 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 177, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_u_right = __pyx_t_4;
   __pyx_t_4 = 0;
-
+178: 	u_top = np.zeros(sal.shape)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+
+179: 	u_top = np.zeros(sal.shape)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -2294,18 +2196,18 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_u_top = __pyx_t_4;
   __pyx_t_4 = 0;
-
+179: 	u_bottom = np.zeros(sal.shape)

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+
+180: 	u_bottom = np.zeros(sal.shape)

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
@@ -2320,19 +2222,19 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 180, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_u_bottom = __pyx_t_4;
   __pyx_t_4 = 0;
-
 180: 

-
+181: 	u_final = np.zeros(sal.shape)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+
 181: 

+
+182: 	u_final = np.zeros(sal.shape)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -2347,15 +2249,15 @@
   __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 181, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_u_final = __pyx_t_4;
   __pyx_t_4 = 0;
-
+182: 	img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_img_lab), __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
+
+183: 	img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)

+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_img_lab), __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(((__pyx_v_img_lab->dimensions[0]) * (__pyx_v_img_lab->dimensions[1]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(((__pyx_v_img_lab->dimensions[0]) * (__pyx_v_img_lab->dimensions[1]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = NULL;
   __pyx_t_6 = 0;
@@ -2372,7 +2274,7 @@
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_1)) {
     PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3};
-    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -2381,14 +2283,14 @@
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
     PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_3, __pyx_int_3};
-    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   } else
   #endif
   {
-    __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 182, __pyx_L1_error)
+    __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 183, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
     if (__pyx_t_2) {
       __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -2399,18 +2301,18 @@
     __Pyx_GIVEREF(__pyx_int_3);
     PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_int_3);
     __pyx_t_3 = 0;
-    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_img_lab_unrolled = __pyx_t_4;
   __pyx_t_4 = 0;
-
 183: 

-
+184: 	px_mean_left_2 = np.zeros((1,3))

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 184, __pyx_L1_error)
+
 184: 

+
+185: 	px_mean_left_2 = np.zeros((1,3))

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 185, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 185, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2425,31 +2327,31 @@
   }
   __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_tuple__7);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 185, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_v_px_mean_left_2 = __pyx_t_4;
   __pyx_t_4 = 0;
 /* … */
-  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_3); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 184, __pyx_L1_error)
+  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_3); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 185, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__7);
   __Pyx_GIVEREF(__pyx_tuple__7);
-
+185: 	px_mean_left_2[0,:] = px_mean_left

-
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_left_2, __pyx_tuple__2, __pyx_v_px_mean_left) < 0)) __PYX_ERR(0, 185, __pyx_L1_error)
-
 186: 

-
+187: 	u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left)

-
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_scipy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error)
+
+186: 	px_mean_left_2[0,:] = px_mean_left

+
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_left_2, __pyx_tuple__2, __pyx_v_px_mean_left) < 0)) __PYX_ERR(0, 186, __pyx_L1_error)
+
 187: 

+
+188: 	u_left = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_left_2,'mahalanobis', VI=cov_left)

+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_scipy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_spatial); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_spatial); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_distance); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_distance); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_cdist); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_cdist); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_INCREF(__pyx_v_img_lab_unrolled);
   __Pyx_GIVEREF(__pyx_v_img_lab_unrolled);
@@ -2460,24 +2362,24 @@
   __Pyx_INCREF(__pyx_n_s_mahalanobis);
   __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
   PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_n_s_mahalanobis);
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_left) < 0) __PYX_ERR(0, 187, __pyx_L1_error)
-  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_left) < 0) __PYX_ERR(0, 188, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3);
   __pyx_t_3 = 0;
-
+188: 	u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1]))

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error)
+
+189: 	u_left = u_left.reshape((img_lab.shape[0],img_lab.shape[1]))

+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_left, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 189, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_GIVEREF(__pyx_t_4);
   PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4);
@@ -2498,16 +2400,16 @@
   __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2);
   __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 188, __pyx_L1_error)
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_3);
   __pyx_t_3 = 0;
-
 189: 

-
+190: 	px_mean_right_2 = np.zeros((1,3))

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error)
+
 190: 

+
+191: 	px_mean_right_2 = np.zeros((1,3))

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 191, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2522,27 +2424,27 @@
   }
   __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_tuple__7);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error)
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 191, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_v_px_mean_right_2 = __pyx_t_3;
   __pyx_t_3 = 0;
-
+191: 	px_mean_right_2[0,:] = px_mean_right

-
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_right_2, __pyx_tuple__2, __pyx_v_px_mean_right) < 0)) __PYX_ERR(0, 191, __pyx_L1_error)
-
 192: 

-
+193: 	u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right)

-
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_scipy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error)
+
+192: 	px_mean_right_2[0,:] = px_mean_right

+
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_right_2, __pyx_tuple__2, __pyx_v_px_mean_right) < 0)) __PYX_ERR(0, 192, __pyx_L1_error)
+
 193: 

+
+194: 	u_right = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_right_2,'mahalanobis', VI=cov_right)

+
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_scipy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_spatial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_spatial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_distance); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_distance); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cdist); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cdist); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_INCREF(__pyx_v_img_lab_unrolled);
   __Pyx_GIVEREF(__pyx_v_img_lab_unrolled);
@@ -2553,24 +2455,24 @@
   __Pyx_INCREF(__pyx_n_s_mahalanobis);
   __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
   PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_n_s_mahalanobis);
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_right) < 0) __PYX_ERR(0, 193, __pyx_L1_error)
-  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 193, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_right) < 0) __PYX_ERR(0, 194, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5);
   __pyx_t_5 = 0;
-
+194: 	u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1]))

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error)
+
+195: 	u_right = u_right.reshape((img_lab.shape[0],img_lab.shape[1]))

+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_right, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 195, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 195, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 195, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 195, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_GIVEREF(__pyx_t_3);
   PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
@@ -2591,16 +2493,16 @@
   __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4);
   __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error)
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 195, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_5);
   __pyx_t_5 = 0;
-
 195: 

-
+196: 	px_mean_top_2 = np.zeros((1,3))

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error)
+
 196: 

+
+197: 	px_mean_top_2 = np.zeros((1,3))

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 196, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2615,27 +2517,27 @@
   }
   __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_tuple__7);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 196, __pyx_L1_error)
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_v_px_mean_top_2 = __pyx_t_5;
   __pyx_t_5 = 0;
-
+197: 	px_mean_top_2[0,:] = px_mean_top

-
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_top_2, __pyx_tuple__2, __pyx_v_px_mean_top) < 0)) __PYX_ERR(0, 197, __pyx_L1_error)
-
 198: 

-
+199: 	u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top)

-
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_scipy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
+
+198: 	px_mean_top_2[0,:] = px_mean_top

+
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_top_2, __pyx_tuple__2, __pyx_v_px_mean_top) < 0)) __PYX_ERR(0, 198, __pyx_L1_error)
+
 199: 

+
+200: 	u_top = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_top_2,'mahalanobis', VI=cov_top)

+
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_scipy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_spatial); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_spatial); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_distance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_distance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_cdist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_cdist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_INCREF(__pyx_v_img_lab_unrolled);
   __Pyx_GIVEREF(__pyx_v_img_lab_unrolled);
@@ -2646,24 +2548,24 @@
   __Pyx_INCREF(__pyx_n_s_mahalanobis);
   __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
   PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_n_s_mahalanobis);
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_top) < 0) __PYX_ERR(0, 199, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_top) < 0) __PYX_ERR(0, 200, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2);
   __pyx_t_2 = 0;
-
+200: 	u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1]))

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error)
+
+201: 	u_top = u_top.reshape((img_lab.shape[0],img_lab.shape[1]))

+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_top, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_5);
   PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
@@ -2684,16 +2586,16 @@
   __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error)
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_2);
   __pyx_t_2 = 0;
-
 201: 

-
+202: 	px_mean_bottom_2 = np.zeros((1,3))

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error)
+
 202: 

+
+203: 	px_mean_bottom_2 = np.zeros((1,3))

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2708,27 +2610,27 @@
   }
   __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_tuple__7);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_px_mean_bottom_2 = __pyx_t_2;
   __pyx_t_2 = 0;
-
+203: 	px_mean_bottom_2[0,:] = px_mean_bottom

-
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_bottom_2, __pyx_tuple__2, __pyx_v_px_mean_bottom) < 0)) __PYX_ERR(0, 203, __pyx_L1_error)
-
 204: 

-
+205: 	u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom)

-
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_scipy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+
+204: 	px_mean_bottom_2[0,:] = px_mean_bottom

+
  if (unlikely(PyObject_SetItem(__pyx_v_px_mean_bottom_2, __pyx_tuple__2, __pyx_v_px_mean_bottom) < 0)) __PYX_ERR(0, 204, __pyx_L1_error)
+
 205: 

+
+206: 	u_bottom = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_bottom_2,'mahalanobis', VI=cov_bottom)

+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_scipy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_spatial); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_spatial); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_distance); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_distance); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_cdist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_cdist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_INCREF(__pyx_v_img_lab_unrolled);
   __Pyx_GIVEREF(__pyx_v_img_lab_unrolled);
@@ -2739,24 +2641,24 @@
   __Pyx_INCREF(__pyx_n_s_mahalanobis);
   __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
   PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_mahalanobis);
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_bottom) < 0) __PYX_ERR(0, 205, __pyx_L1_error)
-  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 205, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_VI, __pyx_v_cov_bottom) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4);
   __pyx_t_4 = 0;
-
+206: 	u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1]))

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error)
+
+207: 	u_bottom = u_bottom.reshape((img_lab.shape[0],img_lab.shape[1]))

+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_u_bottom, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_GIVEREF(__pyx_t_2);
   PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
@@ -2777,16 +2679,16 @@
   __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5);
   __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4);
   __pyx_t_4 = 0;
-
 207: 

-
+208: 	max_u_left = np.max(u_left)

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 208, __pyx_L1_error)
+
 208: 

+
+209: 	max_u_left = np.max(u_left)

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2801,15 +2703,15 @@
   }
   __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_left) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_left);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_v_max_u_left = __pyx_t_4;
   __pyx_t_4 = 0;
-
+209: 	max_u_right = np.max(u_right)

-
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 209, __pyx_L1_error)
+
+210: 	max_u_right = np.max(u_right)

+
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_t_5 = NULL;
@@ -2824,15 +2726,15 @@
   }
   __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_right) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_right);
   __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_max_u_right = __pyx_t_4;
   __pyx_t_4 = 0;
-
+210: 	max_u_top = np.max(u_top)

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error)
+
+211: 	max_u_top = np.max(u_top)

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 211, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -2847,15 +2749,15 @@
   }
   __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_u_top) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_u_top);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_v_max_u_top = __pyx_t_4;
   __pyx_t_4 = 0;
-
+211: 	max_u_bottom = np.max(u_bottom)

-
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 211, __pyx_L1_error)
+
+212: 	max_u_bottom = np.max(u_bottom)

+
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 212, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_t_5 = NULL;
@@ -2870,47 +2772,47 @@
   }
   __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_u_bottom) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_u_bottom);
   __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_max_u_bottom = __pyx_t_4;
   __pyx_t_4 = 0;
-
 212: 

-
+213: 	u_left = u_left / max_u_left

-
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_left, __pyx_v_max_u_left); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 213, __pyx_L1_error)
+
 213: 

+
+214: 	u_left = u_left / max_u_left

+
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_left, __pyx_v_max_u_left); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF_SET(__pyx_v_u_left, __pyx_t_4);
   __pyx_t_4 = 0;
-
+214: 	u_right = u_right / max_u_right

-
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_right, __pyx_v_max_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
+
+215: 	u_right = u_right / max_u_right

+
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_right, __pyx_v_max_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF_SET(__pyx_v_u_right, __pyx_t_4);
   __pyx_t_4 = 0;
-
+215: 	u_top = u_top / max_u_top

-
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_top, __pyx_v_max_u_top); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error)
+
+216: 	u_top = u_top / max_u_top

+
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_top, __pyx_v_max_u_top); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF_SET(__pyx_v_u_top, __pyx_t_4);
   __pyx_t_4 = 0;
-
+216: 	u_bottom = u_bottom / max_u_bottom

-
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_bottom, __pyx_v_max_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error)
+
+217: 	u_bottom = u_bottom / max_u_bottom

+
  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_bottom, __pyx_v_max_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF_SET(__pyx_v_u_bottom, __pyx_t_4);
   __pyx_t_4 = 0;
-
 217: 

-
+218: 	u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom)

-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+
 218: 

+
+219: 	u_max = np.maximum(np.maximum(np.maximum(u_left,u_right),u_top),u_bottom)

+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_maximum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_maximum); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_maximum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_maximum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 219, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
-  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_maximum); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_maximum); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 219, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
   __pyx_t_7 = NULL;
@@ -2928,7 +2830,7 @@
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_8)) {
     PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right};
-    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
     __Pyx_GOTREF(__pyx_t_3);
   } else
@@ -2936,13 +2838,13 @@
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
     PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_u_left, __pyx_v_u_right};
-    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
     __Pyx_GOTREF(__pyx_t_3);
   } else
   #endif
   {
-    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_9);
     if (__pyx_t_7) {
       __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -2953,7 +2855,7 @@
     __Pyx_INCREF(__pyx_v_u_right);
     __Pyx_GIVEREF(__pyx_v_u_right);
     PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_right);
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   }
@@ -2973,7 +2875,7 @@
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_2)) {
     PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -2982,14 +2884,14 @@
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
     PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_3, __pyx_v_u_top};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   } else
   #endif
   {
-    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_9);
     if (__pyx_t_8) {
       __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -3000,7 +2902,7 @@
     __Pyx_GIVEREF(__pyx_v_u_top);
     PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_top);
     __pyx_t_3 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   }
@@ -3020,7 +2922,7 @@
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_5)) {
     PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom};
-    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -3029,14 +2931,14 @@
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
     PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_u_bottom};
-    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else
   #endif
   {
-    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_9);
     if (__pyx_t_2) {
       __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -3047,33 +2949,33 @@
     __Pyx_GIVEREF(__pyx_v_u_bottom);
     PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_u_bottom);
     __pyx_t_1 = 0;
-    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   }
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_v_u_max = __pyx_t_4;
   __pyx_t_4 = 0;
-
 219: 

-
+220: 	u_final = (u_left + u_right + u_top + u_bottom) - u_max

-
  __pyx_t_4 = PyNumber_Add(__pyx_v_u_left, __pyx_v_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
+
 220: 

+
+221: 	u_final = (u_left + u_right + u_top + u_bottom) - u_max

+
  __pyx_t_4 = PyNumber_Add(__pyx_v_u_left, __pyx_v_u_right); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_v_u_top); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_v_u_top); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_v_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_v_u_bottom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_v_u_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_v_u_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF_SET(__pyx_v_u_final, __pyx_t_5);
   __pyx_t_5 = 0;
-
 221: 

-
+222: 	u_max_final = np.max(u_final)

-
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
+
 222: 

+
+223: 	u_max_final = np.max(u_final)

+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 223, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_t_4 = NULL;
@@ -3088,15 +2990,15 @@
   }
   __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_u_final) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_u_final);
   __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error)
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 223, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   __pyx_v_u_max_final = __pyx_t_5;
   __pyx_t_5 = 0;
-
+223: 	sal_max = np.max(sal)

-
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 223, __pyx_L1_error)
+
+224: 	sal_max = np.max(sal)

+
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 224, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   __pyx_t_9 = NULL;
@@ -3111,30 +3013,30 @@
   }
   __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
   __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 223, __pyx_L1_error)
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_v_sal_max = __pyx_t_5;
   __pyx_t_5 = 0;
-
+224: 	sal = sal / sal_max + u_final / u_max_final

-
  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_v_sal_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error)
+
+225: 	sal = sal / sal_max + u_final / u_max_final

+
  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_v_sal_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 225, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_final, __pyx_v_u_max_final); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_final, __pyx_v_u_max_final); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 225, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_9 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __pyx_t_9 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 225, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_9);
   __pyx_t_9 = 0;
-
 225: 

-
 226: 	#postprocessing

-
 227: 

-
 228: 	# apply centredness map

-
+229: 	sal = sal / np.max(sal)

-
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 229, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error)
+
 226: 

+
 227: 	#postprocessing

+
 228: 

+
 229: 	# apply centredness map

+
+230: 	sal = sal / np.max(sal)

+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 230, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_t_4 = NULL;
@@ -3149,19 +3051,19 @@
   }
   __pyx_t_9 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_sal);
   __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error)
+  if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 230, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 230, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_5);
   __pyx_t_5 = 0;
-
 230: 

-
+231: 	s = np.mean(sal)

-
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 231, __pyx_L1_error)
+
 231: 

+
+232: 	s = np.mean(sal)

+
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 232, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 231, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 232, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   __pyx_t_9 = NULL;
@@ -3176,31 +3078,31 @@
   }
   __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
   __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 231, __pyx_L1_error)
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 232, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_v_s = __pyx_t_5;
   __pyx_t_5 = 0;
-
+232: 	cdef double alpha = 50.0

+
+233: 	cdef double alpha = 50.0

 
  __pyx_v_alpha = 50.0;
-
+233: 	cdef double delta = alpha * sqrt(s)

-
  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_s); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 233, __pyx_L1_error)
+
+234: 	cdef double delta = alpha * sqrt(s)

+
  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_s); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 234, __pyx_L1_error)
   __pyx_v_delta = (__pyx_v_alpha * sqrt(__pyx_t_10));
-
 234: 

-
+235: 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))

-
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error)
+
 235: 

+
+236: 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))

+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_meshgrid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_meshgrid); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_arange); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_arange); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -3216,17 +3118,17 @@
   __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
   __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_arange); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_t_3 = NULL;
@@ -3242,7 +3144,7 @@
   __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_8);
   __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -3260,7 +3162,7 @@
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_9)) {
     PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2};
-    __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_GOTREF(__pyx_t_5);
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -3270,7 +3172,7 @@
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
     PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_4, __pyx_t_2};
-    __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_GOTREF(__pyx_t_5);
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -3278,7 +3180,7 @@
   } else
   #endif
   {
-    __pyx_t_8 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_t_8 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
     if (__pyx_t_1) {
       __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); __pyx_t_1 = NULL;
@@ -3289,7 +3191,7 @@
     PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_6, __pyx_t_2);
     __pyx_t_4 = 0;
     __pyx_t_2 = 0;
-    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
   }
@@ -3300,7 +3202,7 @@
     if (unlikely(size != 2)) {
       if (size > 2) __Pyx_RaiseTooManyValuesError(2);
       else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(0, 235, __pyx_L1_error)
+      __PYX_ERR(0, 236, __pyx_L1_error)
     }
     #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
     if (likely(PyTuple_CheckExact(sequence))) {
@@ -3313,15 +3215,15 @@
     __Pyx_INCREF(__pyx_t_9);
     __Pyx_INCREF(__pyx_t_8);
     #else
-    __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_9);
-    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
     #endif
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   } else {
     Py_ssize_t index = -1;
-    __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
+    __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext;
@@ -3329,7 +3231,7 @@
     __Pyx_GOTREF(__pyx_t_9);
     index = 1; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L3_unpacking_failed;
     __Pyx_GOTREF(__pyx_t_8);
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 235, __pyx_L1_error)
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 236, __pyx_L1_error)
     __pyx_t_11 = NULL;
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     goto __pyx_L4_unpacking_done;
@@ -3337,93 +3239,50 @@
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __pyx_t_11 = NULL;
     if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-    __PYX_ERR(0, 235, __pyx_L1_error)
+    __PYX_ERR(0, 236, __pyx_L1_error)
     __pyx_L4_unpacking_done:;
   }
   __pyx_v_xv = __pyx_t_9;
   __pyx_t_9 = 0;
   __pyx_v_yv = __pyx_t_8;
   __pyx_t_8 = 0;
-
+236: 	(w,h) = sal.shape

-
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error)
+
+237: 	cdef int w = sal.shape[0]

+
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 237, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
-    PyObject* sequence = __pyx_t_5;
-    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-    if (unlikely(size != 2)) {
-      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(0, 236, __pyx_L1_error)
-    }
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    if (likely(PyTuple_CheckExact(sequence))) {
-      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); 
-      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); 
-    } else {
-      __pyx_t_8 = PyList_GET_ITEM(sequence, 0); 
-      __pyx_t_9 = PyList_GET_ITEM(sequence, 1); 
-    }
-    __Pyx_INCREF(__pyx_t_8);
-    __Pyx_INCREF(__pyx_t_9);
-    #else
-    __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_9);
-    #endif
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  } else {
-    Py_ssize_t index = -1;
-    __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext;
-    index = 0; __pyx_t_8 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_8)) goto __pyx_L5_unpacking_failed;
-    __Pyx_GOTREF(__pyx_t_8);
-    index = 1; __pyx_t_9 = __pyx_t_11(__pyx_t_2); if (unlikely(!__pyx_t_9)) goto __pyx_L5_unpacking_failed;
-    __Pyx_GOTREF(__pyx_t_9);
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_2), 2) < 0) __PYX_ERR(0, 236, __pyx_L1_error)
-    __pyx_t_11 = NULL;
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    goto __pyx_L6_unpacking_done;
-    __pyx_L5_unpacking_failed:;
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_t_11 = NULL;
-    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-    __PYX_ERR(0, 236, __pyx_L1_error)
-    __pyx_L6_unpacking_done:;
-  }
-  __pyx_v_w = __pyx_t_8;
-  __pyx_t_8 = 0;
-  __pyx_v_h = __pyx_t_9;
-  __pyx_t_9 = 0;
-
+237: 	cdef double w2 = w/2.0

-
  __pyx_t_5 = __Pyx_PyFloat_DivideObjC(__pyx_v_w, __pyx_float_2_0, 2.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 237, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_w2 = __pyx_t_10;
-
+238: 	cdef double h2 = h/2.0

-
  __pyx_t_5 = __Pyx_PyFloat_DivideObjC(__pyx_v_h, __pyx_float_2_0, 2.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_v_w = __pyx_t_6;
+
+238: 	cdef int h = sal.shape[1]

+
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 238, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_h2 = __pyx_t_10;
-
 239: 

-
+240: 	C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2))

-
  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_9);
-  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_v_h = __pyx_t_6;
+
+239: 	cdef double w2 = w/2.0

+
  __pyx_v_w2 = (__pyx_v_w / 2.0);
+
+240: 	cdef double h2 = h/2.0

+
  __pyx_v_h2 = (__pyx_v_h / 2.0);
+
 241: 

+
+242: 	C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2))

+
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
-  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyNumber_Subtract(__pyx_v_xv, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_1 = PyNumber_Subtract(__pyx_v_xv, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_t_2 = NULL;
@@ -3441,23 +3300,23 @@
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_4)) {
     PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2};
-    __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_GOTREF(__pyx_t_8);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else
   #endif
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
     PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_1, __pyx_int_2};
-    __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_GOTREF(__pyx_t_8);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else
   #endif
   {
-    __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     if (__pyx_t_2) {
       __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -3468,19 +3327,19 @@
     __Pyx_GIVEREF(__pyx_int_2);
     PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_int_2);
     __pyx_t_1 = 0;
-    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   }
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = PyNumber_Subtract(__pyx_v_yv, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_2 = PyNumber_Subtract(__pyx_v_yv, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_t_3 = NULL;
@@ -3498,7 +3357,7 @@
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_1)) {
     PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2};
-    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -3507,14 +3366,14 @@
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
     PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2};
-    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   } else
   #endif
   {
-    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_7);
     if (__pyx_t_3) {
       __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
@@ -3525,45 +3384,45 @@
     __Pyx_GIVEREF(__pyx_int_2);
     PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2);
     __pyx_t_2 = 0;
-    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
   }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyNumber_Add(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
-    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
     if (likely(__pyx_t_4)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
       __Pyx_INCREF(__pyx_t_4);
       __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_8, function);
+      __Pyx_DECREF_SET(__pyx_t_9, function);
     }
   }
-  __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_1);
+  __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_1);
   __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error)
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_9 = NULL;
+  __pyx_t_8 = NULL;
   __pyx_t_6 = 0;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
-    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
-    if (likely(__pyx_t_9)) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_8)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_8);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_4, function);
       __pyx_t_6 = 1;
@@ -3571,27 +3430,27 @@
   }
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_4)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_1, __pyx_int_2};
-    __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_GOTREF(__pyx_t_8);
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_1, __pyx_int_2};
+    __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_9);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else
   #endif
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_1, __pyx_int_2};
-    __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_GOTREF(__pyx_t_8);
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_1, __pyx_int_2};
+    __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_9);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else
   #endif
   {
-    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_7);
-    if (__pyx_t_9) {
-      __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL;
+    if (__pyx_t_8) {
+      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL;
     }
     __Pyx_GIVEREF(__pyx_t_1);
     PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_1);
@@ -3599,25 +3458,25 @@
     __Pyx_GIVEREF(__pyx_int_2);
     PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_int_2);
     __pyx_t_1 = 0;
-    __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 240, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
     __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
   }
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_power); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
-  __pyx_t_9 = NULL;
+  __pyx_t_8 = NULL;
   __pyx_t_6 = 0;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
-    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1);
-    if (likely(__pyx_t_9)) {
+    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_8)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
-      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_8);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_1, function);
       __pyx_t_6 = 1;
@@ -3625,27 +3484,27 @@
   }
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_1)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_int_2};
-    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
   } else
   #endif
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_int_2};
-    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+    PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
   } else
   #endif
   {
-    __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
-    if (__pyx_t_9) {
-      __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_9); __pyx_t_9 = NULL;
+    if (__pyx_t_8) {
+      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_8); __pyx_t_8 = NULL;
     }
     __Pyx_GIVEREF(__pyx_t_7);
     PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_t_7);
@@ -3653,66 +3512,66 @@
     __Pyx_GIVEREF(__pyx_int_2);
     PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_int_2);
     __pyx_t_7 = 0;
-    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_1 = PyNumber_Add(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyFloat_FromDouble(sqrt(__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(sqrt(__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_SubtractCObj(__pyx_int_1, __pyx_t_4, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_SubtractCObj(__pyx_int_1, __pyx_t_4, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __pyx_v_C = __pyx_t_1;
   __pyx_t_1 = 0;
-
 241: 

-
+242: 	sal = sal * C

-
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_sal, __pyx_v_C); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
+
 243: 

+
+244: 	sal = sal * C

+
  __pyx_t_1 = PyNumber_Multiply(__pyx_v_sal, __pyx_v_C); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_1);
   __pyx_t_1 = 0;
-
 243: 

-
+244: 	fv = np.vectorize(f)

-
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error)
+
 245: 

+
+246: 	fv = np.vectorize(f)

+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_vectorize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_vectorize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CFunc_object____object___to_py(__pyx_f_12saliency_mbd_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_8 = NULL;
+  __pyx_t_9 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
-    __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5);
-    if (likely(__pyx_t_8)) {
+    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_9)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-      __Pyx_INCREF(__pyx_t_8);
+      __Pyx_INCREF(__pyx_t_9);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_5, function);
     }
   }
-  __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_8, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_9, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error)
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_v_fv = __pyx_t_1;
   __pyx_t_1 = 0;
-
 245: 

-
+246: 	sal = sal / np.max(sal)

-
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error)
+
 247: 

+
+248: 	sal = sal / np.max(sal)

+
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __pyx_t_5 = NULL;
@@ -3727,16 +3586,16 @@
   }
   __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
   __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error)
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4);
   __pyx_t_4 = 0;
-
 247: 

-
+248: 	sal = fv(sal)

+
 249: 

+
+250: 	sal = fv(sal)

 
  __Pyx_INCREF(__pyx_v_fv);
   __pyx_t_1 = __pyx_v_fv; __pyx_t_5 = NULL;
   if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -3750,15 +3609,15 @@
   }
   __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_sal);
   __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error)
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4);
   __pyx_t_4 = 0;
-
 249: 

-
+250: 	return sal* 255.0

+
 251: 

+
+252: 	return sal* 255.0

 
  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 252, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __pyx_r = __pyx_t_4;
   __pyx_t_4 = 0;
diff --git a/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx b/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx
index b14cd85..27a1fcb 100644
--- a/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx
+++ b/perception/tasks/segmentation/saliency_detection/saliency_mbd.pyx
@@ -12,15 +12,14 @@ from libc.math cimport exp, floor, sqrt
 np.import_array()
 
 @cython.boundscheck(False)
+@cython.wraparound(False)
 cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
-	cdef int n_rows
-	cdef int n_cols
-
-	n_rows = len(img)
-	n_cols = len(img[0])
-
-	cdef int x
-	cdef int y
+	# cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double)
+	cdef int n_rows = img.shape[0]
+	cdef int n_cols = img.shape[1]
+	
+	
+	cdef Py_ssize_t x, y
 	cdef double ix
 	cdef double d
 	cdef double u1
@@ -30,16 +29,16 @@ cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, n
 	cdef double b1
 	cdef double b2
 
-	for x in range(1,n_rows - 1):
-		for y in range(1,n_cols - 1):
-			ix = img[x][y]
-			d = D[x][y]
+	for x in xrange(1,n_rows - 1):
+		for y in xrange(1,n_cols - 1):
+			ix = img[x, y]
+			d = D[x,y]
 
-			u1 = U[x-1][y]
-			l1 = L[x-1][y]
+			u1 = U[x-1,y]
+			l1 = L[x-1,y]
 
-			u2 = U[x][y-1]
-			l2 = L[x][y-1]
+			u2 = U[x,y-1]
+			l2 = L[x,y-1]
 
 			b1 = max(u1,ix) - min(l1,ix)
 			b2 = max(u2,ix) - min(l2,ix)
@@ -47,26 +46,26 @@ cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, n
 			if d <= b1 and d <= b2:
 				continue
 			elif b1 < d and b1 <= b2:
-				D[x][y] = b1
-				U[x][y] = max(u1,ix)
-				L[x][y] = min(l1,ix)
+				D[x,y] = b1
+				U[x,y] = max(u1,ix)
+				L[x,y] = min(l1,ix)
 			else:
-				D[x][y] = b2
-				U[x][y] = max(u2,ix)
-				L[x][y] = min(l2,ix)
+				D[x,y] = b2
+				U[x,y] = max(u2,ix)
+				L[x,y] = min(l2,ix)
 
 	return True
 
 @cython.boundscheck(False)
+@cython.wraparound(False)
 cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
 	cdef int n_rows
 	cdef int n_cols
 
-	n_rows = len(img)
-	n_cols = len(img[0])
+	n_rows = img.shape[0]
+	n_cols = img.shape[1]
 
-	cdef int x
-	cdef int y
+	cdef Py_ssize_t x, y
 	cdef double ix
 	cdef double d
 	cdef double u1
@@ -76,17 +75,17 @@ cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2]
 	cdef double b1
 	cdef double b2
 
-	for x in range(n_rows - 2,1,-1):
-		for y in range(n_cols - 2,1,-1):
+	for x in xrange(n_rows - 2,1,-1):
+		for y in xrange(n_cols - 2,1,-1):
 			
-			ix = img[x][y]
-			d = D[x][y]
+			ix = img[x,y]
+			d = D[x,y]
 
-			u1 = U[x+1][y]
-			l1 = L[x+1][y]
+			u1 = U[x+1,y]
+			l1 = L[x+1,y]
 
-			u2 = U[x][y+1]
-			l2 = L[x][y+1]
+			u2 = U[x,y+1]
+			l2 = L[x,y+1]
 
 			b1 = max(u1,ix) - min(l1,ix)
 			b2 = max(u2,ix) - min(l2,ix)
@@ -94,29 +93,30 @@ cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2]
 			if d <= b1 and d <= b2:
 				continue
 			elif b1 < d and b1 <= b2:
-				D[x][y] = b1
-				U[x][y] = max(u1,ix)
-				L[x][y] = min(l1,ix)
+				D[x,y] = b1
+				U[x,y] = max(u1,ix)
+				L[x,y] = min(l1,ix)
 			else:
-				D[x][y] = b2
-				U[x][y] = max(u2,ix)
-				L[x][y] = min(l2,ix)
+				D[x,y] = b2
+				U[x,y] = max(u2,ix)
+				L[x,y] = min(l2,ix)
 
 	return True
 
 @cython.boundscheck(False)
+@cython.wraparound(False)
 cdef mbd(np.ndarray[double, ndim=2] img, int num_iters):
 
-	L = np.copy(img)
-	U = np.copy(img)
-	D = np.full_like(img, 10000000)
+	cdef np.ndarray[double, ndim=2] L = np.copy(img)
+	cdef np.ndarray[double, ndim=2] U = np.copy(img)
+	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
 	D[0,:] = 0
 	D[-1,:] = 0
 	D[:,0] = 0
 	D[:,-1] = 0
 
 	cdef int x
-	for x in range(0,num_iters):
+	for x in xrange(0,num_iters):
 		if x%2 == 1:
 			raster_scan(img,L,U,D)
 		else:
@@ -124,11 +124,12 @@ cdef mbd(np.ndarray[double, ndim=2] img, int num_iters):
 
 	return D
 
-def f(x):
+cdef f(x):
 	b = 10.0
 	return 1.0 / (1.0 + exp(-b*(x - 0.5)))
 
 @cython.boundscheck(False)
+@cython.wraparound(False)
 cpdef get_saliency_mbd(np.ndarray img,method='b'):
 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
 	img_mean = np.mean(img,axis=(2))
@@ -233,7 +234,8 @@ cpdef get_saliency_mbd(np.ndarray img,method='b'):
 	cdef double delta = alpha * sqrt(s)
 
 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))
-	(w,h) = sal.shape
+	cdef int w = sal.shape[0]
+	cdef int h = sal.shape[1]
 	cdef double w2 = w/2.0
 	cdef double h2 = h/2.0
 

From 42cad85fcce33d3c2dbfe80622ffeb38695cd58b Mon Sep 17 00:00:00 2001
From: ayush0624 <31373700+ayush0624@users.noreply.github.com>
Date: Sat, 20 Feb 2021 07:07:46 -0800
Subject: [PATCH 24/43] Added iou function

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 1d86c72..95c7b3e 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -8,6 +8,8 @@
 import queue
 import concurrent.futures
 from multiprocessing import Pool
+from shapely.geometry import Polygon
+
 
 class COMB_SAL_BG(TaskPerceiver):
     def __init__(self, **kwargs):
@@ -26,7 +28,21 @@ def __init__(self, **kwargs):
     #         ret = self.bg.analyze(frame,debug, slider_vals=slider_vals)
     #     return ret
 
-    def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):            
+
+    # def filter_contours(self, contour_main, contour_filter):
+    #     TODO: find algorithm to filter contour_main based upon contour_filter
+
+    def intersection_over_union(polyA, polyB):
+        polygonA_shape = Polygon(polyA)
+        polygonB_shape = Polygon(polyB)
+
+        polygon_intersection = polygonA_shape.intersection(polygonB_shape).area
+        polygon_union = polygonA_shape.area + polygonB_shape.area - polygon_intersection #inclusion exclusion
+
+        IOU = polygon_intersection / polygon_union
+        return IOU
+
+    def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         # sal_thread = Thread(target=self.sal.analyze, args=(frame, debug, slider_vals, self.q))
         # bg_thread = Thread(target=self.bg.analyze, args=(frame, debug, slider_vals, self.q))
         # bg_thread.__setattr__('_args', (frame, debug, slider_vals, self.q))
@@ -39,4 +55,4 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         sal = self.sal.analyze(frame, debug, slider_vals=slider_vals)
         bg = self.bg.analyze(frame,debug, slider_vals=slider_vals)
         ret = cv.bitwise_and(sal[0],bg[0])
-        return frame, [frame, sal[0], bg[0], ret]
\ No newline at end of file
+        return frame, [frame, sal[0], bg[0], ret]

From 83a2186e24566bdec6857e2115a3e44b8ac1cd0f Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 21 Feb 2021 17:04:18 -0800
Subject: [PATCH 25/43] Cleaned Up Combined Algorithm

This commit cleans up all unused code and imports.
---
 perception/tasks/segmentation/COMB_SAL_BG.py  | 25 -------------------
 .../segmentation/saliency_detection/MBD.py    |  2 --
 2 files changed, 27 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 95c7b3e..fb94637 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -4,10 +4,6 @@
 from typing import Dict
 from perception.tasks.segmentation.saliency_detection.MBD import MBD
 from perception.vis.TestTasks.BackgroundRemoval import BackgroundRemoval
-from threading import Thread
-import queue
-import concurrent.futures
-from multiprocessing import Pool
 from shapely.geometry import Polygon
 
 
@@ -16,18 +12,6 @@ def __init__(self, **kwargs):
         super().__init__(blur = ((0, 10), 2), lamda = ((0,10),1), lower_bound=((0,255), 10))
         self.sal = MBD()
         self.bg = BackgroundRemoval()
-        # self.q = queue.Queue()
-
-    # def f(frame: np.ndarray, debug: bool, slider_vals: Dict[str, int], use_mbd: bool):
-    #     print('working!')
-    #     if use_mbd:
-    #         print('Im HERE!!!!')
-    #         ret = self.sal.analyze(frame, debug, slider_vals=slider_vals)
-    #     else:
-    #         print('Im NOT :( HERE!!!!')
-    #         ret = self.bg.analyze(frame,debug, slider_vals=slider_vals)
-    #     return ret
-
 
     # def filter_contours(self, contour_main, contour_filter):
     #     TODO: find algorithm to filter contour_main based upon contour_filter
@@ -43,15 +27,6 @@ def intersection_over_union(polyA, polyB):
         return IOU
 
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
-        # sal_thread = Thread(target=self.sal.analyze, args=(frame, debug, slider_vals, self.q))
-        # bg_thread = Thread(target=self.bg.analyze, args=(frame, debug, slider_vals, self.q))
-        # bg_thread.__setattr__('_args', (frame, debug, slider_vals, self.q))
-        # sal_thread.start()
-        # bg_thread.start()
-        # sal_thread.join()
-        # bg_thread.join()
-        # ret = cv.bitwise_and(self.q.get(),self.q.get())
-
         sal = self.sal.analyze(frame, debug, slider_vals=slider_vals)
         bg = self.bg.analyze(frame,debug, slider_vals=slider_vals)
         ret = cv.bitwise_and(sal[0],bg[0])
diff --git a/perception/tasks/segmentation/saliency_detection/MBD.py b/perception/tasks/segmentation/saliency_detection/MBD.py
index beaa562..df96757 100644
--- a/perception/tasks/segmentation/saliency_detection/MBD.py
+++ b/perception/tasks/segmentation/saliency_detection/MBD.py
@@ -11,6 +11,4 @@ def __init__(self, **kwargs):
 
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         mbd = get_saliency_mbd(frame).astype('uint8')
-        # ret3,th3 = cv.threshold(mbd,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU)
-        # q.put(mbd)
         return mbd, [frame, mbd]

From 7d9a8a88ab073fb4146b67064c7b4b895cf15ac2 Mon Sep 17 00:00:00 2001
From: Shrey A 
Date: Sun, 21 Feb 2021 17:09:57 -0800
Subject: [PATCH 26/43] add gitignore and readme for cython

---
 .gitignore       | 2 ++
 README.md        | 6 ++++++
 requirements.txt | 3 ++-
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index a975e57..55cbe5a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
+build/
 .ipynb_checkpoints/
 *.py[cod]
 *$py.class
@@ -14,6 +15,7 @@ __pycache__/
 
 # C extensions
 *.so
+*.o
 
 # IDE files
 .idea
diff --git a/README.md b/README.md
index 707b51c..b0a5543 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,12 @@ and install it
 
 Also, our training data is stored here https://www.dropbox.com/sh/rrbfqfutrmifrxs/AAAfXxlcCtWZmUELp4wXyTIxa?dl=0 so download it and unzip it in the same folder as `perception`.
 
+### Cython
+To compile cythonized code, run the following commands after `cd`ing into the folder with Cython `setup.py`
+
+    python setup.py build_ext --inplace
+    cythonize file_to_cythonize.pyx
+
 
 ## misc:
 Misc code, camera calibration etc.
diff --git a/requirements.txt b/requirements.txt
index f411292..6f61337 100755
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,4 +4,5 @@ numpy
 matplotlib
 imageio
 imageio-ffmpeg
-pytest
\ No newline at end of file
+pytest
+cython
\ No newline at end of file

From 6e43dc73574b1f3649151b349eb806630904686a Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sat, 27 Feb 2021 17:27:10 -0800
Subject: [PATCH 27/43] Added Contours

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 26 +++++++++++++++++---
 perception/vis/vis.py                        |  2 +-
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index fb94637..48ccd5d 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -27,7 +27,25 @@ def intersection_over_union(polyA, polyB):
         return IOU
 
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
-        sal = self.sal.analyze(frame, debug, slider_vals=slider_vals)
-        bg = self.bg.analyze(frame,debug, slider_vals=slider_vals)
-        ret = cv.bitwise_and(sal[0],bg[0])
-        return frame, [frame, sal[0], bg[0], ret]
+        sal = self.sal.analyze(frame, debug, slider_vals=slider_vals)[0]
+        bg = self.bg.analyze(frame,debug, slider_vals=slider_vals)[0]
+        ret = cv.bitwise_and(sal,bg)
+
+        #Combined Contours
+        _, threshold = cv.threshold(ret, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
+        _, contours, _ = cv.findContours(threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+
+        #BG Contours
+        _, bg_threshold = cv.threshold(bg, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
+        _, bg_contours, _ = cv.findContours(bg_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+        bg_frame = np.copy(frame)
+
+        #Sal Contours
+        _, sal_threshold = cv.threshold(sal, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
+        _, sal_contours, _ = cv.findContours(sal_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+        sal_frame = np.copy(frame)
+
+        cv.drawContours(sal_frame, sal_contours, -1, (255,0,0))
+        cv.drawContours(frame, contours, -1, (0,255,0))
+        cv.drawContours(bg_frame, bg_contours, -1, (0,0,255))
+        return frame, [frame, sal, bg, ret, bg_frame, sal_frame]
diff --git a/perception/vis/vis.py b/perception/vis/vis.py
index a347618..4bcfdb4 100644
--- a/perception/vis/vis.py
+++ b/perception/vis/vis.py
@@ -12,7 +12,7 @@
 def run(data_sources, algorithm, save_video=False):
     out = None
     window_builder = Visualizer(algorithm.kwargs)
-    data = FrameWrapper(data_sources, 0.1)
+    data = FrameWrapper(data_sources, 0.15)
     frame_count = 0
     speed = 1
 

From aed3d6b797d3d35f92af49c9857a988134730570 Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 28 Feb 2021 17:00:11 -0800
Subject: [PATCH 28/43] Added Contours and Centroid Plotting

---
 perception/tasks/segmentation/COMB_SAL_BG.py  |  27 ++++++++++++++----
 .../saliency_mbd.o                            | Bin 240808 -> 0 bytes
 .../saliency_mbd.o                            | Bin 127964 -> 0 bytes
 3 files changed, 22 insertions(+), 5 deletions(-)
 delete mode 100644 perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.7/saliency_mbd.o
 delete mode 100644 perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.8/saliency_mbd.o

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 48ccd5d..19340cf 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -12,9 +12,13 @@ def __init__(self, **kwargs):
         super().__init__(blur = ((0, 10), 2), lamda = ((0,10),1), lower_bound=((0,255), 10))
         self.sal = MBD()
         self.bg = BackgroundRemoval()
+        self.use_saliency = True
 
-    # def filter_contours(self, contour_main, contour_filter):
-    #     TODO: find algorithm to filter contour_main based upon contour_filter
+    def filter_contours(self, contours, contour_filter):
+        return filter(contour_filter, contours)
+
+    def largest_contour(self, contours):
+        return max(contours, key=cv.contourArea)
 
     def intersection_over_union(polyA, polyB):
         polygonA_shape = Polygon(polyA)
@@ -45,7 +49,20 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         _, sal_contours, _ = cv.findContours(sal_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
         sal_frame = np.copy(frame)
 
-        cv.drawContours(sal_frame, sal_contours, -1, (255,0,0))
-        cv.drawContours(frame, contours, -1, (0,255,0))
-        cv.drawContours(bg_frame, bg_contours, -1, (0,0,255))
+        largest_sal_contour = self.largest_contour(sal_contours)
+        largest_combined_contour = self.largest_contour(contours)
+        largest_bg_contour = self.largest_contour(bg_contours)
+
+        cv.drawContours(sal_frame, [largest_sal_contour], -1, (255,0,0))
+        cv.drawContours(frame, [largest_combined_contour], -1, (0,255,0))
+        cv.drawContours(bg_frame, [largest_bg_contour], -1, (0,0,255))
+        
+        M = cv.moments(largest_sal_contour)
+        cv.circle(sal_frame, (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])), 5, (255, 0, 0), 3)
+
+        M = cv.moments(largest_combined_contour)
+        cv.circle(frame, (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])), 5, (0, 255, 0), 3)
+
+        M = cv.moments(largest_bg_contour)
+        cv.circle(bg_frame, (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])), 5, (0, 0, 255), 3)
         return frame, [frame, sal, bg, ret, bg_frame, sal_frame]
diff --git a/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.7/saliency_mbd.o b/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.7/saliency_mbd.o
deleted file mode 100644
index 9de7be1be1d86a9a9c46ee3ab15ae72c1d0d5cc4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 240808
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	^tOo5?BRZP>g1Rm0V&Hlt0LdX&Vg*sYH7#
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∾t@TMxEo$&{xS|LvjYj3x86P;0^UvSd5q%bVpISq!7}e#eKp)woygG!1&SmY13eRW!
zJ&_v2M=yi<3CZ*qQB0jugcZ^szI2L!^mwYXjahtA*!iKd6w9qH1Hn9)KgVTFcW&eV
zS?fIO#D4Kb{`=+YM*ik(2DkFWdEo+fBo#QFJfQYqoKRE6;6c-C1_iQN2*hrEq6E#`??RaT={s
z-Sw%f+*-r_k%wd-_mVrsL_5}b3VA(G=D9U_UatcxB;hxD$>q88h`1(Ad0vr|LTy)g
zg58HCJBj;YTzL%REXW%5La#(p3>xsER(o!ft$d4TDG_1kH*^)dGF)u^qRCj4^~r5c
zM?S|Y4rP6;ACQol%*7iPJDqcxj$}0q2q-oaC4c&Zf8h)d$QT01z%nJEA28?R5D*gC!*{M5-hFNWt@Gb-5d
z#mFlMoXoUP#|Al1%NEAP_4Ab|hQ_io-3@(sYC^(WhB&V>R4s~m;K8hY
zXB=I1DGxE2h@5gInjt_@kM$|D+eL(@GSnHEL)bA^;If8w4!J(RzLif+wBZSV-+Yc1
zj6~|E)|Ga{t~7^v_$_S0<+ME9t?wGga~x_sn$FUPf&SbOd27V_s!yC
zarP_+sC9WV9AZ6&f<@=PzC3lbt|SMK4WVs0l01v1&TzZlXo+d@F@A0f6jz+ZE}E|@f1_CU>)eg$#@7;i9coI8F6jj0Jb!eVU|9foiR_l};t1>W;YLhW=O>$BVBO_4-bI`@QxOXv7)xV)ZX&FPuwR6&b4yKS8H>u~3R-`t*@
zMt&I{USQ4bS-}TkJoND7c5Y9`GWFbcJz03|p3Y9JDX-wr#J3MGky@SCi_RpiOLG^_WbUnHeaBlBv7|-`7YU${zUcTO_5<(a&9Nb8mSeLnqU;gBl5jJm(oI69V97cyF<589nGwMVL72>TCS?slOB!r
zY)=j+Et%CiVVlVNGg|P*csK8KeL%G{`yK6BXxAC(Yq}8YLDXzSz9;u}#`B5yWauvO
zcAa9LfOU4JM*6_dxA3luwIob-3GuvdV;#KJd69E*0(UAd>yw@pq#`c_Sq~5(Yj244
zaDwx?-D5qaGsjy8$SC#md-t%{Y%Ucdq+8HxarOl<^5Rx?=k39|yquL_Hz}f(<7}#Z
z91E|!&XwnkZ_J!Ew_*g76;}gy^r#?{an|o6oIyRehu7}D+#ZbE`eJ#b(;g$jSs)(l
zLG`e?Xh@&(SVu-UtNx-M63xj&bsinH;8lvaWfUjgW{Iiqyt-N-J+7%!hqCeBKcY;w
zT8F!{KdocM(M=VkNutceEOl|#CnI>(gNu(RdlcFom)X_(@-%-$x%87~
zdJwH1i>v8(E%s2F60*Dacs@9J^wkab$M{5(M`x!QY_!W5o%9)TdOypyd|LWHa+DUdhOP-NP>AdXr+Gh-cMtD(uYqqD!w~pJw4r
zy0pAO!tmVGqrk57ndE6BmD|AD!qU@R9s}huFF7wL$-ANQ&SYnMAQ@ug&tzjaoh`5S
z)U$Z|k*If%U|=)fZKL1H%bJm{@F>|H#g5=LA9=yec}>_gMQm4&kcXY0(uNIr$Ek)h
zeXpe3)1h{gcD+?jdD)*tFf^JoX+285=tO&Zc$|=?JiKCxrCax-?1_@M_RJE}{pDpz
zd98@I(+0Xa$t?qU9cA*$V?z8;aX*oAq&2x1-#YC*K0;m{wodgpU`H|`+%+O!HmASz
zh@m>hACP*L>0r@qG9AQGbM#`$@%=?%tHMKVD}rmQg$dH{h;(On7Q^4-Tgr$3ElP{u
z)Y1;MYJ~F&oi$ZHMmQg*@iBbxKW0F3e`mF@PpnY8LBvU_DCoIhAziRD%_)y|(O&sG8P)j8#GM!Y*B~GtMAqdIc+j;G~xALS1j|-Q0JVrzIOoy2*21V
zK}WL6f{{RBB=_=Ov*e!FBCT{LuujO)bdOrI`z5&YWq-SVXuM=^zhv(@vUjB~ciVe{0cLERw5OwBmU#2}M!3M&#T{&}BuD=CaYe^zu#@ImV+Xv@fuD8?UabkXpd-
zf~Eib*|wT^<&5~)=wfNRL!=WDew|%C!m7bbRMb^HNs*E@q&hhAvg>L>*S#R@yhucu
z4Z>e1S04L(kKLa8a|-XFQ`8OX+KBu3qaGRT@{pY`HiS>WiP!E>Ce=i%%T0{e><}CC
zc>tf;`ZVXRjJMz|mZO?%>N=veu&&h)vBd7LV$*(9M~OX3#TNZoyPWTH^e^H29M;>T
zq~BYswug{c+0C(1QxHD%q&TwK>*{)+3r?-P~J;-=HiY0HsxAT84bUsI+Z$!=aL@%`-NkKdDnH}%LVICsLo}&%y
zMlPa!bA!2_!biBQH@nKoh8e#m1!ug{LpI;y;Z3|p?Z10_i_@^Yb5AEe
z#M|@T@-SZXPsXfK-(cKbj341%g~ivmmxm#80(vuq&B*dgOY9-mSFs+MgqG8TaJDa&
z7dc#E7jUF@-E4=`TnrBx!H-<(ys2`O@NTXWiSaNoYO_7q%~6rr2urq!mL8xnQk8F
z-_)dRyN-rRWqO@4$f=YO#caQy5hbsQ^R+SFD5@^iAT^Ku%Z_nxnvP34WBh%kaj&Yz
zRt@7j-Z8(+nEz5~&J|RkZ=ZQz$NZ0xPFC*h=FdvMvzuS+n4d7__y3JK9gWPiHgCKf
z#FmC#+AXd~c5-d4_iC3j`FO2`8_kymj%^N+L!Ijv
z+tpWA#$Ptk(2cFRrL;v$wtccok*^Fje4fdBlk-I?YiVhSH;67mFit+k$VaJN>mJdc
zbo6|Tk&j+c#>wvDHw2p-;dA@h%@cS;K=bo`HBq9Gop~D$t*s!{7{S+p<@;CxU(2E!
zU%(mghGI^dER0@j4qf;<>(>s>>v(f08-xDz#qwCTF7I5HvE{Ma$xPr(?2XHL!nQFZ
zU%s_Qw|OX%=QJ}Yw>10V{>}r1#h1_(cwQnqxn)j}e66b0Hq)9~)zR
z)qy>qevlxq2`VCJuLS7_Iqdwvaw1Dja=GMnjhV1_R!-R5Eczxixf^|n+dF5Qx6)Yd
zuC(k^Y3ZRD9M&F5tZ+J4h;^^mO9`BDPRZzE`uxs6i(cfhqglTR^nLesKhriBW6mVP
z7jOP;oI_s>58xpa*JhckfCGO9ZB~1j(#kuQv~i8(5JFS)gC%QcHk84;XaWqh-&I_C_QRkk^fj`Ubf9XG6|
zWQt1)52oL4m>F+9v?avD6I{lxJjZpt#+*u54zcFTd8KwlSWFW;f+sD`C}89Fx0|Kw
ze48bix+*tIl2D9QEV*W@R=!!j^w@;MG?$=EB(hDb6?S1G9%__Wt7XNfh`()MV@+Ed+&e_hF-D+4jF-m5yoyiFL!}nJ?Ir~jQQ!2SqSjGH
zQrgxeF040ym@DMoyZFQO{FcYEEzQNztpA7kv8x7Be<@`72P5%6tjL-AWN$He;_ioP6*z6X2>`9kW0?g4K!l%N_Dp%|iO^gKN-#07d^c+=`#Is$Z%4LbwHeKHQIe
zE|mB`&*sN@kUxjd!R_#K_!f+#zF&qPAdiLo?ZQsK=9_jp0wulu%ExXu`M4X3{&u*5
z^gQrI;#~({M^1qIkn2OqcQq*Xzs@rDUqP||1d9C|Q0!lVVqXl!{&84J_;mO@`WxX*
z!*Ni`(_6#4!0XUosNs#_lZ4lWQ_uIZspIwqK}0y
z!!K_!_5D7S_+?7@@kwb9H(ZauL@4eAG)t?8&Uvs#Uar5g8)Bh@<#QO@qho9Xl
zPk_?jxG
zU9NI66u&*8_-zWsZ$l`4tHW&g6P;4x?}y@d6BNI%!YSxiL-D&5rlEfrW+G38VwVZU
zE)|O1SSWU*RNo1T-FYyB@D@<)YC^HA2Gfxb(AmUp53G&+F%-KkQ0!iZ{JGcYB~a`h
zfRmB$fnp~=kSlgMs=o}TqK}73=zBtG*I1a0zCE;H6T<~zP}=_|I;q(G0LAVbmA`;n
zY42@N?6#_YJrujODnAEh{M`rlV>egzH$e|}*--Lxt?I9W5`QR6ftP4_M-4wu!&|^f
zgrBA}$h`Ukq#dVx17F48ekl3=6mB5>9dIrBwGg`n&lpBO4rLvD1lGh~0hD-iAoVz9
z29*ABIb4I?5GdgnL&;}Pl{-PHj}vstHP{`6V)r!^yFDs@2&F#OK&g*sRsRT-ak&tR
zeI}d;Q=!z)Xej=MDPy46w^z9dydL}7@EP>gpd0y5I`wt195#pV!)9<3ycVv5$FMJk
zVaQLyYv4ohYIv`P=fereIdD8oSG^l1B3}x}!QrZpgI6JUgjd4zRNn-SMXmv_fMKdX
z#h|+!`4GGeeg!38AHgxmTj8Z}Jv@efH5`px1iQdTRlfiZM4kgj!KpA7W@&gbj6uFe
z!$-o-$V1>U{PuYfSd=~vjsxO7_
zBEJN`fvezP?4E{$U=fsf55wj3^SMyUI}7f@J{?|&JW1utU=8GWm3zV%G+0O?N+EjR%E?@V^0{~3zD93GT>!JpvMumau!pMaC#DcBG8Cw>e(jNBepCw^-v
z_1g?eIl^H>7z%e__dAoQ*d2jlw;ziB3)OFfjPK~JP}YHUQ2eZfm%!yv^0gR>pZQS6
z&1@+7yG8XL*c`nZ{(wFa_COv1x6vQ^z;)<5z^`C+DD5Vby!id%2BUu)id+hR#_o01
zFID|LQ0BF{D&Goaou3RP-xHwBgLUC*Ne8|N|6&n%9lIZ)=#N6t?^k`f>fcrUo2q|J
z^{Z9CQuUco`d>1X{7!)M`%%N-e)N~9J{pQ$eU<-Wagy+#p~U+bO87RFU)AszR9>Lr
z`6_2=c&f@{p|o2UxCcgSctZ`B#Zculkhe0
zJ2($Yea(bYUpK)`*!PAE{(^w&eN4^#b5EJ~vP7K;9MDE7&!zXtY3PSEhds_(9hQ8rgb
zK(YUEobeZVrSWe;@q3a*P0~A{+zln&_f#%X-VA$UKLz%J<5iA
zB4?>QS>@I$H&gkg%Z=Zu%GS_H|1zU@k1?EnsnIupCHT)AZTR&l)9>Gezme}(RDKq|
zhTTLc^V%@@4stB~6@EU_=r=&oKLtgf3V(+aq2zxY6u-macj!Z*l=t@p6J7x~6aE@p
zi@pd(z&qd%@LDMGx+|MQ@!uGV{|G4le~UME$6!aoUxQCE&Yp+cVHT8mG6l+cXPnBh
z%5$K^+dabAy$K_b7emR%1StMSLGjlYioe=$1>vWM^J9P1(;+DB_Z5`CAd
z%4eXoQxO#V2UR~`^?6YId0-2vf0bjP_-hKg6YtAmMqURk(z^#ry0@!-68svwD7X*)
zHq`K-aDE0K|5Yt{CLGk+zl=j-7`gN*brTWKJzf|=PsD7^M^Ho1h^?$HA
zk^XQRivJ&=_}{PkFI4}L>IXxq@3v6t=j%bH9Ug_}pq~e8qQ4!AzuIsG`X2@w`{$ta
zQ~42VsrS2~*iDC9NcS4mU#a>*s*hEDd(}5q{m%o8pW{&cd-ZR>I+oPR@trc5S8Pg^rPbt1^bYBy`6L!PyMJVwWsD7-nqlVYg@FRUpymiV&
zP~uOA68}oocTidyet^kW!b_p#D-y~)5dp)bzL`wRD91bSE%dLe{5X_&bChGD#7lq@
zuM?DbwN(Ct$ywt607YL8CH_mw*-+xofD->YD0aP7ZVx4XGu4MdiGPU6Q}{BJ_|HL!
zzW_@7sVaM*#2=^nOQ6JSqx`YEiGLJI{P&>5e@5j;p~Syi^*K=DU!`md*CIEA68{e-
z5sAMaiu@sz_*+%~9F+L?DW}p{N0B>0*~henAHs7~{|m;_Ki`Ma&&r_mvrSOOWeJpV
z`5csSG8oFZYzrlx{3yK0KXx(lekk%5m0wi(5tXljzY^XEwuIlsns{rK9w_>O$`;Ds
zIvcyW@Nx1#6w0{k3_pggSp;NUG=q}zeeSSD&MYhs>;_vsgH3`
z>SG8LKeZrL*XjEUO+CK@rGGyJMW3ho%TynwJl@`f?}SuYr`1s6Wh;kkcsmUbSN+a*
z#_ky?{_lbkKSlMul@S_#^a2z978L(Yp!A=*Q2NW4=bQdh3Z>sXr}9E5ey1u2Ly6ZH
zO1x-TM)^;lXXL~1Ey6#8qTdW9exWi4O8hh^@kc|kYp-$>DDi8mzM`#(U#@%tO8g~I
z;@=7-ev-({XYcP5S|aE-lxHh=tsgj*bjlVVI8;+I~$69MPp-s7>fN`DE9Y5
z=|{6+JLFp+LoxbBXv0)^n(zrw{MLj_F`a&HWb*Sm6#uKB^DQn&r9%p;uS-NVDxe*`FR9Ne(r|i_hKmdxe!YIeA~eI{}hV<
z_n`QH97=wcK#AvplAmj!t{5UuE@u3R1=DQHFzG}Ti4jX55-=7)@-{y#%Gco`IXGuSelp^bf+l@LKpC?5>Q4zaz`<153P`@HgW9PNj+6
zBFIo%AitK&P+l+(HsRwm_zB^y;rFm6dAaR$HGssZ>IW(
znY_e)4wUeo@EO7zL8gf4I*_R#`gbO`ljsk@AEEqgvgG>%kOZt`;!u0j49N_qDvKZILI
z|5Zp8b$T9BP(yN@JOorkoQRT~&-QeTow*i!TIYHvm&%T3_kNx~d
z`dJy2bT+HLL|F{Q?+TS4Re2sff&Ex0{qs+k$@k9?Rl`#F1^RW6As_t=WGHu90wq7=
zpu`&n#m^oFO)GOsJdA~O$>{cwt`OY_K8Kz-&OBNQNhcaxr#z2ADaS)l
z%5^7{bf!T`r#~dgXvz|@8$ZOAf6=S)i%sp7@McIIh+o%XNc+{^3u&*~Ww0My2m3(r
zOO)E#Q0#}p8OZ(Nbl47F3{R7(W$-w>2JVD~kgraLEQKo}d9PgrZ-TQR^;mlvbi+ir
z1df4|VJut>+d%t-MIF*
zKG+hDhSF&F!qYU?AowX<0C&P0;c9pfTnVLp=E1w+EJ!=lz8=npiEuFN1@D5fa2}NY
zHy4J(EO?kkq)*h|3+uvCI0vqS?cpLQ{X%|E^g5Ug?}YN(nQh>3cn9ncqhL!o8%9Br
zaQag|JWhWIhdbfzunZ1^E8#3y1V=zVhs=c1zb=Q=X~=Dmx(Z2vvG7*d4qgTE8FC8*
z^8B-Q(vwcVbd6UIQ(mI%plqY8r>vno^@NH4gEC1uR{6jR6MnaH?s6l~RK8kdLB9u6#wgN;zHGLfJ_98-q*Y{iys*`GN8k7+R8teyd>Rkm0v4&
zE9WX_DyJw@l$R+-D0?b9E1M}Jm7&UCm?S0LgUTRUuU952*RyCy{Fjx>l#eLyRNkueDw`=Il|QlAh@bD3
zA1SvhUsOJ$yiYk-IYpVGj8_g+wpX@N)>7Ka6D)3${t@MJ<)g~mmD817l<*{TSu>$`;CBZ!zH&%1@N?o@prcyiU1VIanE|l=nTwEIO
z<&(;#$~ns0ls77mk1ETR?y%z)hSH_HF~#^vQ(mAv
zS6NGGD^E-^_D7VTDBoAUu6#+kT=}SSyz(+-Z)F$du4LnXhjN~BmNHj)c%re}s~mZm
zkq0Yl4RQ9ZuAc`R?o)1uHubq$<;BW7l$pvz1F(Xpj-vT|D7-t-m09Wyhb@d*<0CC8Ksox%o6`6(
zR=%seRhg$uR$i?fro2SiNqL^Kp0bAW=L<}F$CNK9pH>zq=P7SgrYSF1#w)uiJ19ey
zznpK<*`?f}d|6qn%va7(j!_O*woo=w%0onHCwYHDcucup*|x3GH&+(5G4dj1bEUkO
zAo1U5ZMZ_YM0tnu7Gy%e1
z_p~&AcPU?2zNB2NT&TQ7=~d>RYvRvPUZ=cD*-zPB*<9H``DY6g|CF+t^7m+?->dvo
zxk>q|vQYW3a+Y$M@{Z=l&n-%~a-4Fs@?vF-@<>y&Px(l>LHV@ue&x-|t6(VoV6<|G
z>N_i&C@tmpO^p9?WvOzJGGCdYyh`~^;RWu9`1vX?Se`AMXSw@vwGeIsvB4pH_~HdfYA{#?)4
zA60&#yjppMGE{k@uCd>z90uh)*IMPK%4(`l4l&_FVKwYn)|_%O9XXWeFH&xK{vzzJ
zY^e-U?j=ydOO-{+S<35`{go}1A~aWkPvxqqc#y+Iug%ZXeW92vicIs
z(MbJ>yiVnU8b&^?ax1kjRr#A*COo9SiQg{5$aPhoP9=-KD3!0FpNQO2a&0{$f>rP|8nuk>>XZ{YK=K
zDt|2bqkfKS{n!$p{FK%){^J-YV&6{veS%)(GL1h;>u0CRuV{UIs&XC4KlXc7KB(ni
zH_+7AO!dD~s9_m+helIk7#+aRZiFP
zO!I|H{>enk5hlH#7;la|(#UUU{moK)dH+h%o2PPD4KGmn3(e0Wm2XzLNacN`CH`ln
z82{T;F7g<8gyfh05w7()L;4doV=gt}Ns>R(Kd%0cYkw|CG~t)%c-uM7$XVD*{L+a=
zzDwJuDAmX{#h&z5`_dDC#5t}052?TYHyHbw*vfd=tM*aaze5I?{*@&4Pn+*tZ0zsW
z^3T%nU$nmFsrXFvdXJ9e22nH->Kn8G=47)Z&Tfbuhj6*
zG`zotf1u$78vc%k57+QCt-nPYK0*8A7!5BWZAt%A4Uf?9L=B&z{`YG5F7wg
zBz}m>12ufI%3F1Q%hveU=y*P^^0{iCt@a(IeWm~2Vfur-wTi~YU##Vsr*g5@Z-L6gw0;(;{2kp;{6}ein(BBim~H&CO?1LrYWOAEf7_`XtKqRK
zpVa==OXWH`pY>OHj;1$U<<;7M$EX~q^K+ug5h`D=^5dHSBF%q2>3@_l`%aVJ=Vbg*
zp2=$eozy=z>va6xtMxHW!*}X@Q98%OA1VI$|E&2&zEbDwQk5^2{z3geul4_@^bh3z
z_Za&{(w@k(RQ_80A+Jz*jM}eO`7mJ;zDwm)mG`N9m!yyGJD)7&M?Rr)rtyMm)^-=1pZ)tzRJ8O7TX&>Z1D)&-(kjlSFe;|Cg%42F7
z`BIhtkp4?}qRO#ao@|xJN&18rsJu%0FY+3d52;+L^3z&>$5lS4<*TplF+j^7rE=R^
z#$OASlQh4vDpyx|n9Ao#et$n$Bf&*#dA{QJ{QlQ2ch}EinAqpzwMG
z28K^Mr>gvIkpJ6*?1xfcf$>KN#a|qh-+P1da}nbuF#a~`J5X*M6yBTm3JkxR`U{k0
zSq_vxXS@W;&jyueN07WONM1nO1;)Q3D1CVkFEG45{WVa2EGS&w4-E`&8zip?l5Y-@
zYX-?9g35P2<0H`j>>&BNp!WYcsJxE_g=YlGdX6KO`PU$*zH0`hcUe&Q3(RMM`TGht
zf%3&c>E#6Z+ZI&bPlNp57ZksDPULEBByCD0kg8V%lG+v{rjKKO>7UX|N(EL;_
z$o{6F^h$#2`^%vCotQrZ(|b9nK6?e#&#giEZ5|ZhNWO=_n
zFn?Qu!aoX<*96I52E{KAD({k@_6~8o-PzNpxij6l?&PfO={`BViX@?#c~dHbMUk7F
zR;ft$iDRaZ&YLnZCC5D~FTjYX<3=>(J40#aa2Qca@^yRaxzt#nv~%l!heS5Buz;P(hbU*q^gl=xn6N0J_n~I
z`#(Fed;w$gvNKYAg2eTGz9J(nSp`#3>Dlf)U-sQ;R7;lEJv1xFo0F7Dm1TOJWCx_i*%
zl;rfwQx$>Jtu5?Pjn0>d1Yq%<}sFXakvPF}L6JQSx@6r-~;{jx8!ZlX&MkfKV_#!UBj
zF{!FSNf{X?c+7NDYKfrbbfWnk(Va|fNCu@>QtOopjcj1zk4%}Gl2K`)L*$CQiS!$j
zp~}`sbtmPzJsDX^PDVv9Z4#&*GyTfUv}Ea}LvymG(EFx{t;tEHG%_nQ)iJmtH*H3W
z+waX8yVG+k8$35aI7{yyRN1csA_aBqvl&fsy2vEDNNz@!*NH3DJ|iV3%kM}slQb>O
zFQ@w@(?Z(mq;0wm$Vv6vrA%QMxF=3$nE0A=N?K-KF3s+@$-c?mrE6|dMp{Z{@^tr<
ziId#jQd7L{KuwGp)Y;RMa#AztpMGbiGKZy2O<}f4PRW*uXjGDyu8D~WJX3F+O-b=i
z&YI+yY3}JA1H9fGiKrSnmZQmV$K*;tl@RHKV~jazxG$ZWl0$d6iGG$PrvCZbbg(Mw
ziFs+vx|up^s|2N2RZ<3gS8-uf6KI~nX;af=2&)4VaK-doCYCBbrS+~#%E(KpqV;9s
z%#idd*2Zn1mC;Deq)p88`n($LSeB0}$w=at=P~0l`3F{wFZr{Dr3b|@uB%!a-Dp`;
z0^K?jKhugkGs#Q0aQdD*D`yf*ovZ=5dD%>(zUE11n*5iR*%ZSpipg0yDegSR@?^Is
zDJ>&qlG~eQX5&h?|JqUpvY89q^sqFh0)`Niuh(&#<<6ZPnA?B0WI;~K&SlD%NpVb8
zTBbL}U)m}wk|%@uaRLK-`@lSp$3&2EjWl$M*F88TH<^}Bk)|CqISGH%J+tYcj1&=4
zre*sIE^VFZm(l}22i4yc*>*Uai^@v$c_E%`VwlgU=>KFW$>pY}O-V{kai?WfMi11P
ztd5q+H-q`rKN~oOU}yy>%yKhmWLjnl6+Ms;VhV(WfM(`E!z9MRGz@k^(~=NjEXN`3RWk&eV{kY*2h9l@CE%
zhp8zt-HX8)Yk)6SU<2iO(;VY$XQlKtkx!fJrKa73?~d
z>4EN(GiWY1bEz!RPJ8)6ad(z5XWB3eg=`1>t?Wy3z@$k5I`%crmU9fb!$Rv%>&Bgs
znRQd<@TAo{?Id*e*WN`FQ)8Bf;I+~p-#_|lZ`uzMSlt-+ZRudIA`c3278Yn+e*!t=>uh(
zVzy#VOAN@IbcN%%>PF5KKOoT5rCR#-5}G3!8vk)dNls$3GRe*PD9>MnGs>NM_Wh7E
zt^6woL37L5;;?XXoJq<}XHHE?osyEtHlL}kavwG+#p};u_H-K7oy>8-=%ko3OPTe9
zx?#JJHpvO3UY$k7eR&G&MJ_HFR5Dfv%7`DHlH+K6J$O*ol5eb(G&)Iysv$j-
zv!}C-%XDAl82St(J7&)`)``NHljEgN7)Um>oqVdHvXS>2_zxVu;L203PvZ&H-?q#UTR)a
zjz6yC)ErPMy;aK6g3jsNoy&s3UeDR)W#=$Jb7Evy5U6mcIbJ1>PU4p*rRA~_%I2CN
zg)p;2x-^;lfE**sRYB#rXYTN2;>`K_jH8;*)T!%$L!D1=76iFyaWWcs%JZ3+$t7i4
zO7dAVamMTzkU^(7qf(|Y**N=XDV>O;R65J7lIP(9%a?Sn*@JtNCi*n~4^kk%kY4#Q
z*SUIVIs@wV4qiKFuL8ngXCU8a!;RpwlW8976T{rn65oT
z%z-t=A79h!@o)XFSTBDO}`F;UC=i
z^XQKuLosXO4Q_WAze=5U^Ep+yOE+J({UMAYcUPa8bBg?@(^i1_Kc3+#Z8Zn}q8k1k#Pp+0|pg~aU=
PYySCM1f&rg67qill95-&

diff --git a/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.8/saliency_mbd.o b/perception/tasks/segmentation/saliency_detection/build/temp.macosx-10.9-x86_64-3.8/saliency_mbd.o
deleted file mode 100644
index 2851c4937bbcf79004245d63d6abdfb461ef46fe..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 127964
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
Date: Sun, 7 Mar 2021 10:54:48 -0800
Subject: [PATCH 29/43] Implemented basics of switching

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 47 ++++++++++++++------
 1 file changed, 33 insertions(+), 14 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 19340cf..1cb6d7e 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -9,10 +9,12 @@
 
 class COMB_SAL_BG(TaskPerceiver):
     def __init__(self, **kwargs):
-        super().__init__(blur = ((0, 10), 2), lamda = ((0,10),1), lower_bound=((0,255), 10))
+        super().__init__(switch_threshold=((5,255), 10))
         self.sal = MBD()
         self.bg = BackgroundRemoval()
         self.use_saliency = True
+        self.prev_centroid = (0,0)
+        self.changed = True
 
     def filter_contours(self, contours, contour_filter):
         return filter(contour_filter, contours)
@@ -30,14 +32,16 @@ def intersection_over_union(polyA, polyB):
         IOU = polygon_intersection / polygon_union
         return IOU
 
+    def switch_algorithm(self):
+        self.use_saliency = not self.use_saliency
+        self.changed = True
+
+    def compute_centroid_change(self, point1, point2):
+        return abs(point1[0] - point2[0]) + abs(point1[1] - point2[1])
+
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         sal = self.sal.analyze(frame, debug, slider_vals=slider_vals)[0]
         bg = self.bg.analyze(frame,debug, slider_vals=slider_vals)[0]
-        ret = cv.bitwise_and(sal,bg)
-
-        #Combined Contours
-        _, threshold = cv.threshold(ret, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
-        _, contours, _ = cv.findContours(threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
 
         #BG Contours
         _, bg_threshold = cv.threshold(bg, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
@@ -50,19 +54,34 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         sal_frame = np.copy(frame)
 
         largest_sal_contour = self.largest_contour(sal_contours)
-        largest_combined_contour = self.largest_contour(contours)
         largest_bg_contour = self.largest_contour(bg_contours)
 
         cv.drawContours(sal_frame, [largest_sal_contour], -1, (255,0,0))
-        cv.drawContours(frame, [largest_combined_contour], -1, (0,255,0))
         cv.drawContours(bg_frame, [largest_bg_contour], -1, (0,0,255))
         
         M = cv.moments(largest_sal_contour)
-        cv.circle(sal_frame, (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])), 5, (255, 0, 0), 3)
+        centroid_sal = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
+        cv.circle(sal_frame, centroid_sal, 5, (255, 0, 0), 3)
 
-        M = cv.moments(largest_combined_contour)
-        cv.circle(frame, (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])), 5, (0, 255, 0), 3)
+        M_bg = cv.moments(largest_bg_contour)
+        centroid_bg = (int(M_bg["m10"] / M_bg["m00"]), int(M_bg["m01"] / M_bg["m00"]))
+        cv.circle(bg_frame, centroid_bg, 5, (0, 0, 255), 3)
 
-        M = cv.moments(largest_bg_contour)
-        cv.circle(bg_frame, (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])), 5, (0, 0, 255), 3)
-        return frame, [frame, sal, bg, ret, bg_frame, sal_frame]
+        
+        if self.use_saliency:
+            returned_contour = largest_sal_contour
+            used_centroid = centroid_sal
+        else:
+            returned_contour = largest_bg_contour
+            used_centroid = centroid_bg
+        
+        if self.changed:
+            self.changed = False
+        else:
+            if self.compute_centroid_change(used_centroid, self.prev_centroid) > slider_vals['switch_threshold']:
+                self.switch_algorithm()
+                print('Switched!')
+        self.prev_centroid = used_centroid
+        cv.circle(frame, used_centroid, 5, (0, 255, 0), 3)
+        cv.drawContours(frame, [returned_contour], -1, (0,255,0))
+        return returned_contour, [frame, sal, bg, bg_frame, sal_frame]

From 9b54b5e9c781fff82789e6c1596dcad4c9fa06cd Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 7 Mar 2021 11:13:49 -0800
Subject: [PATCH 30/43] Fixed to being in opencv version 4

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 1cb6d7e..65c3107 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -45,14 +45,14 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
 
         #BG Contours
         _, bg_threshold = cv.threshold(bg, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
-        _, bg_contours, _ = cv.findContours(bg_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+        bg_contours, _ = cv.findContours(bg_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
         bg_frame = np.copy(frame)
 
         #Sal Contours
         _, sal_threshold = cv.threshold(sal, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
-        _, sal_contours, _ = cv.findContours(sal_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+        sal_contours, _ = cv.findContours(sal_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
         sal_frame = np.copy(frame)
-
+        
         largest_sal_contour = self.largest_contour(sal_contours)
         largest_bg_contour = self.largest_contour(bg_contours)
 

From a54ea2111711650ca2a2fe5b260827e6eb1e45ab Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 7 Mar 2021 13:38:05 -0800
Subject: [PATCH 31/43] Added slider to change if both algorithms should run

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 85 ++++++++++++--------
 1 file changed, 52 insertions(+), 33 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 65c3107..c9db2ce 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -9,7 +9,7 @@
 
 class COMB_SAL_BG(TaskPerceiver):
     def __init__(self, **kwargs):
-        super().__init__(switch_threshold=((5,255), 10))
+        super().__init__(switch_threshold=((5,255), 10), run_both=((0,1),0))
         self.sal = MBD()
         self.bg = BackgroundRemoval()
         self.use_saliency = True
@@ -39,41 +39,57 @@ def switch_algorithm(self):
     def compute_centroid_change(self, point1, point2):
         return abs(point1[0] - point2[0]) + abs(point1[1] - point2[1])
 
+    def analyze_specific_img(self, frame: np.ndarray, algorithm, debug: bool, slider_vals:Dict[str, int]):
+        analysis = algorithm(frame, debug, slider_vals=slider_vals)[0]
+        _, threshold = cv.threshold(analysis, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
+        contours, _ = cv.findContours(threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+        largest_contour = self.largest_contour(contours)
+        contour_frame = np.copy(frame)
+        cv.drawContours(contour_frame, [largest_contour], -1, (255,0,0))
+        return largest_contour, [analysis, contour_frame]
+
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
-        sal = self.sal.analyze(frame, debug, slider_vals=slider_vals)[0]
-        bg = self.bg.analyze(frame,debug, slider_vals=slider_vals)[0]
-
-        #BG Contours
-        _, bg_threshold = cv.threshold(bg, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
-        bg_contours, _ = cv.findContours(bg_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
-        bg_frame = np.copy(frame)
-
-        #Sal Contours
-        _, sal_threshold = cv.threshold(sal, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
-        sal_contours, _ = cv.findContours(sal_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
-        sal_frame = np.copy(frame)
-        
-        largest_sal_contour = self.largest_contour(sal_contours)
-        largest_bg_contour = self.largest_contour(bg_contours)
+        if not slider_vals['run_both']:
+            if self.use_saliency:
+                returned_contour, analysis = self.analyze_specific_img(frame, self.sal.analyze, debug, slider_vals)
+            else:
+                returned_contour, analysis = self.analyze_specific_img(frame, self.bg.analyze, debug, slider_vals)
+            M = cv.moments(returned_contour)
+            used_centroid = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
+        else:
+            sal = self.sal.analyze(frame, debug, slider_vals=slider_vals)[0]
+            bg = self.bg.analyze(frame,debug, slider_vals=slider_vals)[0]
 
-        cv.drawContours(sal_frame, [largest_sal_contour], -1, (255,0,0))
-        cv.drawContours(bg_frame, [largest_bg_contour], -1, (0,0,255))
-        
-        M = cv.moments(largest_sal_contour)
-        centroid_sal = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
-        cv.circle(sal_frame, centroid_sal, 5, (255, 0, 0), 3)
+            #BG Contours
+            _, bg_threshold = cv.threshold(bg, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
+            bg_contours, _ = cv.findContours(bg_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+            bg_frame = np.copy(frame)
 
-        M_bg = cv.moments(largest_bg_contour)
-        centroid_bg = (int(M_bg["m10"] / M_bg["m00"]), int(M_bg["m01"] / M_bg["m00"]))
-        cv.circle(bg_frame, centroid_bg, 5, (0, 0, 255), 3)
+            #Sal Contours
+            _, sal_threshold = cv.threshold(sal, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
+            sal_contours, _ = cv.findContours(sal_threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+            sal_frame = np.copy(frame)
+            
+            largest_sal_contour = self.largest_contour(sal_contours)
+            largest_bg_contour = self.largest_contour(bg_contours)
 
-        
-        if self.use_saliency:
-            returned_contour = largest_sal_contour
-            used_centroid = centroid_sal
-        else:
-            returned_contour = largest_bg_contour
-            used_centroid = centroid_bg
+            cv.drawContours(sal_frame, [largest_sal_contour], -1, (255,0,0))
+            cv.drawContours(bg_frame, [largest_bg_contour], -1, (0,0,255))
+            
+            M = cv.moments(largest_sal_contour)
+            centroid_sal = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
+            cv.circle(sal_frame, centroid_sal, 5, (255, 0, 0), 3)
+
+            M_bg = cv.moments(largest_bg_contour)
+            centroid_bg = (int(M_bg["m10"] / M_bg["m00"]), int(M_bg["m01"] / M_bg["m00"]))
+            cv.circle(bg_frame, centroid_bg, 5, (0, 0, 255), 3)
+
+            if self.use_saliency:
+                returned_contour = largest_sal_contour
+                used_centroid = centroid_sal
+            else:
+                returned_contour = largest_bg_contour
+                used_centroid = centroid_bg
         
         if self.changed:
             self.changed = False
@@ -84,4 +100,7 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         self.prev_centroid = used_centroid
         cv.circle(frame, used_centroid, 5, (0, 255, 0), 3)
         cv.drawContours(frame, [returned_contour], -1, (0,255,0))
-        return returned_contour, [frame, sal, bg, bg_frame, sal_frame]
+
+        if slider_vals['run_both']:
+            return returned_contour, [frame, sal, bg, bg_frame, sal_frame]
+        return returned_contour, [frame] + analysis
\ No newline at end of file

From ff47724616e1bac7cb57d272fc08d56d2f01b4ca Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 7 Mar 2021 16:54:41 -0800
Subject: [PATCH 32/43] Added 0 area protections

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index c9db2ce..bb902b2 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -55,7 +55,10 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
             else:
                 returned_contour, analysis = self.analyze_specific_img(frame, self.bg.analyze, debug, slider_vals)
             M = cv.moments(returned_contour)
-            used_centroid = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
+            if M["m00"] == 0:
+                used_centroid = (int(M["m10"]), int(M["m00"]))
+            else:
+                used_centroid = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
         else:
             sal = self.sal.analyze(frame, debug, slider_vals=slider_vals)[0]
             bg = self.bg.analyze(frame,debug, slider_vals=slider_vals)[0]

From acb528ef623b41253e2b3d73493e78aa49f759b8 Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Fri, 26 Mar 2021 16:30:43 -0700
Subject: [PATCH 33/43] Added sliders for area_percentage_weight and
 centroid_distance_weight

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index bb902b2..8e8d61a 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -9,12 +9,15 @@
 
 class COMB_SAL_BG(TaskPerceiver):
     def __init__(self, **kwargs):
-        super().__init__(switch_threshold=((5,255), 10), run_both=((0,1),0))
+        super().__init__(heuristic_threshold=((5,255), 35), run_both=((0,1),0), 
+            centroid_distance_weight=((0,200),1), area_percentage_weight=((0,200),30))
         self.sal = MBD()
         self.bg = BackgroundRemoval()
         self.use_saliency = True
         self.prev_centroid = (0,0)
         self.changed = True
+        self.centroid_distance_weight = 1
+        self.area_percentage_weight = 1
 
     def filter_contours(self, contours, contour_filter):
         return filter(contour_filter, contours)
@@ -36,8 +39,8 @@ def switch_algorithm(self):
         self.use_saliency = not self.use_saliency
         self.changed = True
 
-    def compute_centroid_change(self, point1, point2):
-        return abs(point1[0] - point2[0]) + abs(point1[1] - point2[1])
+    def compute_heuristic(self, point1, point2, contour_area, img_area):
+        return self.centroid_distance_weight * (abs(point1[0] - point2[0]) + abs(point1[1] - point2[1])) + self.area_percentage_weight * contour_area / img_area
 
     def analyze_specific_img(self, frame: np.ndarray, algorithm, debug: bool, slider_vals:Dict[str, int]):
         analysis = algorithm(frame, debug, slider_vals=slider_vals)[0]
@@ -97,13 +100,15 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         if self.changed:
             self.changed = False
         else:
-            if self.compute_centroid_change(used_centroid, self.prev_centroid) > slider_vals['switch_threshold']:
+            if self.compute_heuristic(used_centroid, self.prev_centroid, cv.contourArea(returned_contour), 
+                np.shape(frame)[0] * np.shape(frame)[1]) > slider_vals['heuristic_threshold']:
                 self.switch_algorithm()
                 print('Switched!')
         self.prev_centroid = used_centroid
         cv.circle(frame, used_centroid, 5, (0, 255, 0), 3)
         cv.drawContours(frame, [returned_contour], -1, (0,255,0))
-
+        self.centroid_distance_weight = slider_vals['centroid_distance_weight']
+        self.area_percentage_weight = slider_vals['area_percentage_weight']
         if slider_vals['run_both']:
             return returned_contour, [frame, sal, bg, bg_frame, sal_frame]
         return returned_contour, [frame] + analysis
\ No newline at end of file

From 7d0861e0ee9fc9fb0dbedf0a3ce863b71db243f6 Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 28 Mar 2021 16:34:48 -0700
Subject: [PATCH 34/43] Added multi-contour output

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 8e8d61a..7bc73ea 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -10,14 +10,15 @@
 class COMB_SAL_BG(TaskPerceiver):
     def __init__(self, **kwargs):
         super().__init__(heuristic_threshold=((5,255), 35), run_both=((0,1),0), 
-            centroid_distance_weight=((0,200),1), area_percentage_weight=((0,200),30))
+            centroid_distance_weight=((0,200),1), area_percentage_weight=((0,200),30), num_contours=((1,5), 1))
         self.sal = MBD()
         self.bg = BackgroundRemoval()
         self.use_saliency = True
         self.prev_centroid = (0,0)
         self.changed = True
         self.centroid_distance_weight = 1
-        self.area_percentage_weight = 1
+        self.area_percentage_weight = 10
+        self.num_contours = 1
 
     def filter_contours(self, contours, contour_filter):
         return filter(contour_filter, contours)
@@ -25,6 +26,13 @@ def filter_contours(self, contours, contour_filter):
     def largest_contour(self, contours):
         return max(contours, key=cv.contourArea)
 
+    def largest_contours(self, contours):
+        contours.sort(key=cv.contourArea)
+        num_selected = self.num_contours
+        if len(contours) < num_selected:
+            num_selected = len(contours)
+        return contours[-self.num_contours:]
+
     def intersection_over_union(polyA, polyB):
         polygonA_shape = Polygon(polyA)
         polygonB_shape = Polygon(polyB)
@@ -46,9 +54,10 @@ def analyze_specific_img(self, frame: np.ndarray, algorithm, debug: bool, slider
         analysis = algorithm(frame, debug, slider_vals=slider_vals)[0]
         _, threshold = cv.threshold(analysis, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
         contours, _ = cv.findContours(threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
-        largest_contour = self.largest_contour(contours)
+        biggest_contours = self.largest_contours(contours)
+        largest_contour = biggest_contours[-1]
         contour_frame = np.copy(frame)
-        cv.drawContours(contour_frame, [largest_contour], -1, (255,0,0))
+        cv.drawContours(contour_frame, biggest_contours, -1, (255,0,0))
         return largest_contour, [analysis, contour_frame]
 
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
@@ -109,6 +118,7 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         cv.drawContours(frame, [returned_contour], -1, (0,255,0))
         self.centroid_distance_weight = slider_vals['centroid_distance_weight']
         self.area_percentage_weight = slider_vals['area_percentage_weight']
+        self.num_contours = slider_vals['num_contours']
         if slider_vals['run_both']:
             return returned_contour, [frame, sal, bg, bg_frame, sal_frame]
         return returned_contour, [frame] + analysis
\ No newline at end of file

From 5b579066af4bb57758c3cb79b7767295e4ed10ab Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 4 Apr 2021 12:21:27 -0700
Subject: [PATCH 35/43] Updated to reflect debug mode

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 32 ++++++++++++--------
 1 file changed, 19 insertions(+), 13 deletions(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 7bc73ea..94423a6 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -10,14 +10,14 @@
 class COMB_SAL_BG(TaskPerceiver):
     def __init__(self, **kwargs):
         super().__init__(heuristic_threshold=((5,255), 35), run_both=((0,1),0), 
-            centroid_distance_weight=((0,200),1), area_percentage_weight=((0,200),30), num_contours=((1,5), 1))
+            centroid_distance_weight=((0,200),1), area_percentage_weight=((0,200),60), num_contours=((1,5), 1))
         self.sal = MBD()
         self.bg = BackgroundRemoval()
         self.use_saliency = True
         self.prev_centroid = (0,0)
         self.changed = True
         self.centroid_distance_weight = 1
-        self.area_percentage_weight = 10
+        self.area_percentage_weight = 60
         self.num_contours = 1
 
     def filter_contours(self, contours, contour_filter):
@@ -55,17 +55,20 @@ def analyze_specific_img(self, frame: np.ndarray, algorithm, debug: bool, slider
         _, threshold = cv.threshold(analysis, 100, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
         contours, _ = cv.findContours(threshold, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
         biggest_contours = self.largest_contours(contours)
-        largest_contour = biggest_contours[-1]
-        contour_frame = np.copy(frame)
-        cv.drawContours(contour_frame, biggest_contours, -1, (255,0,0))
-        return largest_contour, [analysis, contour_frame]
+        if debug:
+            contour_frame = np.copy(frame)
+            cv.drawContours(contour_frame, biggest_contours, -1, (255,0,0))
+            return biggest_contours, [analysis, contour_frame]
+        return biggest_contours, [analysis]
 
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
-        if not slider_vals['run_both']:
+        if not slider_vals['run_both'] or not debug:
             if self.use_saliency:
                 returned_contour, analysis = self.analyze_specific_img(frame, self.sal.analyze, debug, slider_vals)
             else:
                 returned_contour, analysis = self.analyze_specific_img(frame, self.bg.analyze, debug, slider_vals)
+            if len(returned_contour) == 1:
+                returned_contour = returned_contour[0]
             M = cv.moments(returned_contour)
             if M["m00"] == 0:
                 used_centroid = (int(M["m10"]), int(M["m00"]))
@@ -112,13 +115,16 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
             if self.compute_heuristic(used_centroid, self.prev_centroid, cv.contourArea(returned_contour), 
                 np.shape(frame)[0] * np.shape(frame)[1]) > slider_vals['heuristic_threshold']:
                 self.switch_algorithm()
-                print('Switched!')
         self.prev_centroid = used_centroid
-        cv.circle(frame, used_centroid, 5, (0, 255, 0), 3)
-        cv.drawContours(frame, [returned_contour], -1, (0,255,0))
+
         self.centroid_distance_weight = slider_vals['centroid_distance_weight']
         self.area_percentage_weight = slider_vals['area_percentage_weight']
         self.num_contours = slider_vals['num_contours']
-        if slider_vals['run_both']:
-            return returned_contour, [frame, sal, bg, bg_frame, sal_frame]
-        return returned_contour, [frame] + analysis
\ No newline at end of file
+        if debug:
+            cv.circle(frame, used_centroid, 5, (0, 255, 0), 3)
+            cv.drawContours(frame, [returned_contour], -1, (0,255,0))
+            if slider_vals['run_both']:
+                return returned_contour, [frame, sal, bg, bg_frame, sal_frame]
+            else:
+                return returned_contour, [frame] + analysis
+        return returned_contour
\ No newline at end of file

From 300de4e15a428357d22ffc716cad943493133dfe Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 11 Apr 2021 12:10:44 -0700
Subject: [PATCH 36/43] Integrated saliency detection with roulette algo

---
 perception/__init__.py                       |  4 +-
 perception/tasks/roulette/color_detection.py | 94 ++++++++++++++++++++
 perception/tasks/segmentation/COMB_SAL_BG.py | 13 +--
 3 files changed, 105 insertions(+), 6 deletions(-)
 create mode 100644 perception/tasks/roulette/color_detection.py

diff --git a/perception/__init__.py b/perception/__init__.py
index 1fa218d..1a2550b 100644
--- a/perception/__init__.py
+++ b/perception/__init__.py
@@ -6,6 +6,7 @@
 import perception.tasks.segmentation.saliency_detection.MBD as MBD
 from perception.tasks.segmentation.COMB_SAL_BG import COMB_SAL_BG
 import perception.vis.TestTasks.BackgroundRemoval as BackgroundRemoval
+import perception.tasks.roulette.color_detection as RouletteColorDetector
 # import perception.tasks as tasks
 
 ALGOS = {
@@ -16,5 +17,6 @@
     'gatesegC': GateSegC.GateSegmentationAlgoC,
     'MBD': MBD.MBD,
     'bg-rm': BackgroundRemoval.BackgroundRemoval,
-    'combined': COMB_SAL_BG
+    'combined': COMB_SAL_BG,
+    'roulette': RouletteColorDetector.RouletteColorDetector
 }
diff --git a/perception/tasks/roulette/color_detection.py b/perception/tasks/roulette/color_detection.py
new file mode 100644
index 0000000..1a2e517
--- /dev/null
+++ b/perception/tasks/roulette/color_detection.py
@@ -0,0 +1,94 @@
+import numpy as np
+import argparse
+import cv2 as cv
+import heapq
+from perception.tasks.TaskPerceiver import TaskPerceiver
+from typing import Dict
+from perception.tasks.segmentation.COMB_SAL_BG import COMB_SAL_BG
+
+class RouletteColorDetector(TaskPerceiver):
+    def __init__(self, **kwargs):
+        super().__init__(heuristic_threshold=((5,255), 35), run_both=((0,1),0), 
+            centroid_distance_weight=((0,200),1), area_percentage_weight=((0,200),60), num_contours=((1,5), 1))
+        self.sal = COMB_SAL_BG()
+        self.sal.set_num_contours(3)
+        self.sal.use_saliency = False
+
+    def draw_centers_of_largest_contours(self, img, n, contours, color, size, offset=(0,0), f=cv.contourArea):
+        largest_n_contours = heapq.nlargest(n,contours,key=f)
+        cv.drawContours(img,largest_n_contours,-1,color,size, offset=offset)
+        for c in largest_n_contours:
+            M = cv.moments(c)
+            if M["m00"] != 0.0:
+            # Offset due to the processing on an extracted image (x,y) + (center in other imagex, center in other image y)
+                cX = offset[0] + int(M["m10"] / M["m00"])
+                cY = offset[1] + int(M["m01"] / M["m00"])
+                cv.circle(img, (cX, cY), size, color, -1)
+
+    def heuristic(self, contour):
+        rect = cv.minAreaRect(contour)
+        area = rect[1][0] * rect[1][1]
+        diff = cv.contourArea(cv.convexHull(contour)) - cv.contourArea(contour)
+        cent = rect[0]
+        heur = 3 * area - 9 * diff
+        return heur
+
+    def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
+        contours = self.sal.analyze(frame, False, slider_vals)
+        if len(contours) > 0:
+            single_contour_list = np.concatenate(contours)
+            x,y,w,h = cv.boundingRect(single_contour_list)
+            spinner = frame[y:y+h, x:x+w]
+
+            hsv_spinner = cv.cvtColor(spinner,cv.COLOR_BGR2HSV)
+            blurred_spinner = cv.bilateralFilter(hsv_spinner,7,50,50)
+            bgr_blurred_spinner = cv.cvtColor(blurred_spinner,cv.COLOR_HSV2BGR)
+
+            # Index 0: Hue, Index 1: Saturation, Index 2: Value
+            individual_channels = cv.split(blurred_spinner)
+
+            individual_channels[0] = cv.equalizeHist(individual_channels[0])
+            individual_channels[1] = cv.equalizeHist(individual_channels[1])
+            individual_channels[2] = cv.equalizeHist(individual_channels[2])
+
+            equalized_image = cv.merge((individual_channels[0],individual_channels[1],individual_channels[2]))
+
+            # Background Green Detection
+            Lab_spinner = cv.cvtColor(bgr_blurred_spinner, cv.COLOR_BGR2LAB)
+            Lab_individual_channels = cv.split(Lab_spinner)
+            _ , L_threshold = cv.threshold(Lab_individual_channels[0],1,255,cv.THRESH_BINARY|cv.THRESH_OTSU)
+            _ , a_threshold = cv.threshold(Lab_individual_channels[1],1,255,cv.THRESH_BINARY_INV|cv.THRESH_OTSU)
+            b_threshold_value, b_threshold_background = cv.threshold(Lab_individual_channels[2],1,255,cv.THRESH_BINARY|cv.THRESH_OTSU)
+            b_bias = 3
+            b_threshold_background_value = b_bias + b_threshold_value
+            _, b_threshold_background = cv.threshold(Lab_individual_channels[2],b_threshold_background_value,255,cv.THRESH_BINARY)
+
+            b_edges_bias = 5
+            b_threshold_edges = b_threshold_value - b_edges_bias
+            _, b_threshold_edges = cv.threshold(Lab_individual_channels[2],b_threshold_edges,255,cv.THRESH_BINARY_INV)
+
+            # General Thresholds
+            _, hue_threshold_norm = cv.threshold(individual_channels[0],0,255,cv.THRESH_BINARY|cv.THRESH_OTSU)
+            _, saturation_threshold_inv = cv.threshold(individual_channels[1],0,255,cv.THRESH_BINARY_INV|cv.THRESH_OTSU)
+            _, value_threshold_inv = cv.threshold(individual_channels[2],0,255,cv.THRESH_BINARY_INV|cv.THRESH_OTSU)
+
+            # red_threshold = hue_threshold_norm & saturation_threshold_inv & value_threshold_inv & !b_threshold_background
+            red_threshold = cv.bitwise_and(cv.bitwise_and(hue_threshold_norm, cv.bitwise_and(saturation_threshold_inv, value_threshold_inv)),cv.bitwise_not(b_threshold_background))
+            red_contours, _ = cv.findContours(red_threshold,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)
+            self.draw_centers_of_largest_contours(frame,2,red_contours,(0,0,255),3,offset=(x,y))
+
+            # black_threshold = hue_threshold_norm & !saturation_threshold_inv & value_threshold_inv & !b_threshold_background
+            black_threshold = cv.bitwise_and(cv.bitwise_and(hue_threshold_norm, cv.bitwise_and(cv.bitwise_not(saturation_threshold_inv), value_threshold_inv)),cv.bitwise_not(b_threshold_background))
+            black_contours, _ = cv.findContours(black_threshold,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)
+            self.draw_centers_of_largest_contours(frame,2,black_contours,(0,0,0),3,offset=(x,y))
+
+            # green_threshold = !saturation_threshold_inv & !value_threshold_inv & !b_threshold_background & !b_threshold_edges
+            green_threshold = cv.bitwise_and(cv.bitwise_and(cv.bitwise_and(cv.bitwise_not(saturation_threshold_inv), cv.bitwise_not(value_threshold_inv)),cv.bitwise_not(b_threshold_background)),cv.bitwise_not(b_threshold_edges))
+            kernel = np.ones((6,6),np.uint8)
+            green_threshold = cv.morphologyEx(green_threshold,cv.MORPH_OPEN,kernel)
+            green_contours, _ = cv.findContours(green_threshold,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)
+            self.draw_centers_of_largest_contours(frame,2,green_contours,(0,255,0),3,offset=(x,y), f=self.heuristic)
+
+            # Showing Spinner Bounding Box
+            cv.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),2)
+        return [red_contours, green_contours, black_contours], [frame]
\ No newline at end of file
diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 94423a6..09d9fba 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -60,6 +60,9 @@ def analyze_specific_img(self, frame: np.ndarray, algorithm, debug: bool, slider
             cv.drawContours(contour_frame, biggest_contours, -1, (255,0,0))
             return biggest_contours, [analysis, contour_frame]
         return biggest_contours, [analysis]
+    
+    def set_num_contours(self, num_contours):
+        self.num_contours = num_contours
 
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         if not slider_vals['run_both'] or not debug:
@@ -67,9 +70,8 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
                 returned_contour, analysis = self.analyze_specific_img(frame, self.sal.analyze, debug, slider_vals)
             else:
                 returned_contour, analysis = self.analyze_specific_img(frame, self.bg.analyze, debug, slider_vals)
-            if len(returned_contour) == 1:
-                returned_contour = returned_contour[0]
-            M = cv.moments(returned_contour)
+            largest_contour = returned_contour[0]
+            M = cv.moments(largest_contour)
             if M["m00"] == 0:
                 used_centroid = (int(M["m10"]), int(M["m00"]))
             else:
@@ -108,11 +110,12 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
             else:
                 returned_contour = largest_bg_contour
                 used_centroid = centroid_bg
+            returned_contour = [returned_contour]
         
         if self.changed:
             self.changed = False
         else:
-            if self.compute_heuristic(used_centroid, self.prev_centroid, cv.contourArea(returned_contour), 
+            if self.compute_heuristic(used_centroid, self.prev_centroid, cv.contourArea(returned_contour[0]), 
                 np.shape(frame)[0] * np.shape(frame)[1]) > slider_vals['heuristic_threshold']:
                 self.switch_algorithm()
         self.prev_centroid = used_centroid
@@ -122,7 +125,7 @@ def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         self.num_contours = slider_vals['num_contours']
         if debug:
             cv.circle(frame, used_centroid, 5, (0, 255, 0), 3)
-            cv.drawContours(frame, [returned_contour], -1, (0,255,0))
+            cv.drawContours(frame, returned_contour, -1, (0,255,0))
             if slider_vals['run_both']:
                 return returned_contour, [frame, sal, bg, bg_frame, sal_frame]
             else:

From c4ba9bad7ee31383202a75ed5bfcc1c480c69b6d Mon Sep 17 00:00:00 2001
From: Shrey 
Date: Sun, 11 Apr 2021 16:49:16 -0700
Subject: [PATCH 37/43] saliency with the predefined array and loops

---
 .../prange_saliency_mbd.pyx                   | 222 ++++++++++++++++++
 .../segmentation/saliency_detection/setup.py  |   6 +-
 2 files changed, 226 insertions(+), 2 deletions(-)
 create mode 100644 perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx

diff --git a/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx b/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx
new file mode 100644
index 0000000..caeaf30
--- /dev/null
+++ b/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx
@@ -0,0 +1,222 @@
+import sys
+import numpy as np
+cimport numpy as np
+import scipy.spatial.distance
+import skimage
+import skimage.io
+from skimage.util import img_as_float
+from scipy.optimize import minimize
+cimport cython
+from libc.math cimport exp, floor, sqrt
+from cython.parallel cimport prange
+
+np.import_array()
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
+	# cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double)
+	cdef int n_rows = img.shape[0]
+	cdef int n_cols = img.shape[1]
+	
+	
+	cdef Py_ssize_t x, y
+	cdef double ix
+	cdef double d
+	cdef double u1
+	cdef double l1
+	cdef double u2
+	cdef double l2
+	cdef double b1
+	cdef double b2
+
+	for x in xrange(1,n_rows - 1):
+		for y in xrange(1,n_cols - 1):
+			ix = img[x, y]
+			d = D[x,y]
+
+			u1 = U[x-1,y]
+			l1 = L[x-1,y]
+
+			u2 = U[x,y-1]
+			l2 = L[x,y-1]
+
+			b1 = max(u1,ix) - min(l1,ix)
+			b2 = max(u2,ix) - min(l2,ix)
+
+			if d <= b1 and d <= b2:
+				continue
+			elif b1 < d and b1 <= b2:
+				D[x,y] = b1
+				U[x,y] = max(u1,ix)
+				L[x,y] = min(l1,ix)
+			else:
+				D[x,y] = b2
+				U[x,y] = max(u2,ix)
+				L[x,y] = min(l2,ix)
+
+	return True
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
+	cdef int n_rows
+	cdef int n_cols
+
+	n_rows = img.shape[0]
+	n_cols = img.shape[1]
+
+	cdef Py_ssize_t x, y
+	cdef double ix
+	cdef double d
+	cdef double u1
+	cdef double l1
+	cdef double u2
+	cdef double l2
+	cdef double b1
+	cdef double b2
+
+	for x in xrange(n_rows - 2,1,-1):
+		for y in xrange(n_cols - 2,1,-1):
+			
+			ix = img[x,y]
+			d = D[x,y]
+
+			u1 = U[x+1,y]
+			l1 = L[x+1,y]
+
+			u2 = U[x,y+1]
+			l2 = L[x,y+1]
+
+			b1 = max(u1,ix) - min(l1,ix)
+			b2 = max(u2,ix) - min(l2,ix)
+
+			if d <= b1 and d <= b2:
+				continue
+			elif b1 < d and b1 <= b2:
+				D[x,y] = b1
+				U[x,y] = max(u1,ix)
+				L[x,y] = min(l1,ix)
+			else:
+				D[x,y] = b2
+				U[x,y] = max(u2,ix)
+				L[x,y] = min(l2,ix)
+
+	return True
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef mbd(np.ndarray[double, ndim=2] img, int num_iters):
+
+	cdef np.ndarray[double, ndim=2] L = img[...]
+	cdef np.ndarray[double, ndim=2] U = img[...]
+	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
+	D[0,:] = 0
+	D[-1,:] = 0
+	D[:,0] = 0
+	D[:,-1] = 0
+
+	cdef int x
+	for x in xrange(0,num_iters):
+		if x%2 == 1:
+			raster_scan(img,L,U,D)
+		else:
+			raster_scan_inv(img,L,U,D)
+
+	return D
+
+cdef mbd_1(val, n_cols, border_thickness):
+	x, v2 = val
+	px, cov, px_mean = v2
+	px_mean[x] = np.mean(px[x],axis=(0,1))
+	px[x] = px[x].reshape((n_cols*border_thickness,3))
+	cov[x] =  np.linalg.inv(np.cov(px[x].T))
+
+cdef f(x):
+	b = 10.0
+	return 1.0 / (1.0 + exp(-b*(x - 0.5)))
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef get_saliency_mbd(np.ndarray img,method='b'):
+	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
+	img_mean = np.mean(img,axis=(2))
+	sal = mbd(img_mean,2)
+
+	cdef int n_rows = img.shape[0]
+	cdef int n_cols = img.shape[1]
+	cdef int n_channels = img.shape[2]
+	cdef double img_size = sqrt(n_rows * n_cols)
+	cdef border_thickness = int(floor(0.1 * img_size))
+
+	cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img))
+	
+	## Process Left right
+	cdef np.ndarray px_1 = np.zeros((2,border_thickness,img_lab.shape[1], img_lab.shape[2]))
+	px_1[0] = img_lab[0:border_thickness,:,:]
+	px_1[1] = img_lab[n_rows - border_thickness-1:-1,:,:]
+	
+	## Process Top bottom
+	cdef np.ndarray px_2 = np.zeros((2,img_lab.shape[0],border_thickness,img_lab.shape[2]))
+	px_2[0] = img_lab[:,0:border_thickness,:]
+	px_2[1] = img_lab[:,n_cols - border_thickness-1:-1,:]
+	
+	## Combine into one array for easy access
+	cdef px = [px_1,px_2]
+	
+	cdef  np.ndarray px_mean = np.zeros((4,3))
+	cdef  np.ndarray cov = np.zeros((4,3,3))
+	cdef px_new = [np.zeros((2, n_cols*border_thickness,3)), np.zeros((2, n_rows*border_thickness,3))]
+	
+	# with multiprocessing.Pool(processes=len(px)) as pool:
+	# 	pool.starmap(mbd_1, (enumerate(zip(px, cov, px_mean)), n_cols, border_thickness))
+	#TODO: work on prange implementation to not use numpy (to circumvent GIL)
+	for x in xrange(4):
+		px_mean[x] = np.mean(px[x//2][x%2],axis=(0,1))
+		px_new[x//2][x%2] = px[x//2][x%2].reshape(((n_cols if x//2 == 0 else n_rows)*border_thickness,3))
+		cov[x] =  np.linalg.inv(np.cov(px_new[x//2][x%2].T))
+
+	u = np.zeros((4,img_lab.shape[0],img_lab.shape[1]), dtype=np.float)
+
+	img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)
+	px_mean_2 = np.zeros((4,1,3), dtype=np.float)
+	for x in xrange(4):
+		px_mean_2[x,0] = px_mean[x]
+		u[x] = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_2[x],'mahalanobis', VI=cov[x]).reshape((img_lab.shape[0],img_lab.shape[1]))
+		u[x] = u[x]/np.max(u[x])
+		
+
+	u_max = np.maximum(np.maximum(u[0],u[1]),np.maximum(u[2],u[3]))
+
+	u_final = np.sum (u,axis = 0) - u_max
+
+	u_max_final = np.max(u_final)
+	sal_max = np.max(sal)
+	sal = sal / sal_max + u_final / u_max_final
+
+	#postprocessing
+
+	# apply centredness map
+	sal = sal / np.max(sal)
+	
+	s = np.mean(sal)
+	cdef double alpha = 50.0
+	cdef double delta = alpha * sqrt(s)
+
+	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))
+	cdef int w = sal.shape[0]
+	cdef int h = sal.shape[1]
+	cdef double w2 = w/2.0
+	cdef double h2 = h/2.0
+
+	C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2))
+
+	sal = sal * C
+
+	fv = np.vectorize(f)
+
+	sal = sal / np.max(sal)
+
+	sal = fv(sal)
+
+	return sal* 255.0
\ No newline at end of file
diff --git a/perception/tasks/segmentation/saliency_detection/setup.py b/perception/tasks/segmentation/saliency_detection/setup.py
index c2c4e91..64682d5 100644
--- a/perception/tasks/segmentation/saliency_detection/setup.py
+++ b/perception/tasks/segmentation/saliency_detection/setup.py
@@ -1,8 +1,10 @@
 from distutils.core import Extension, setup
 from Cython.Build import cythonize
+from Cython.Distutils import build_ext
 import numpy
 # define an extension that will be cythonized and compiled
 ext = Extension(name="saliency_mbd", sources=["saliency_mbd.pyx"])
-setup(ext_modules=cythonize(ext),
-include_dirs=[numpy.get_include()])
+ext2 = Extension(name="prange_saliency_mbd", sources=["prange_saliency_mbd.pyx"])
+setup(ext_modules=[ext2,ext], include_dirs=[numpy.get_include()],
+    cmdclass = {'build_ext': build_ext})
  
\ No newline at end of file

From 43fa064c9d32d8ce11fe575e10155dc95ce6f31a Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 18 Apr 2021 16:28:57 -0700
Subject: [PATCH 38/43] Added dice detector

---
 perception/__init__.py                |  5 +++--
 perception/tasks/dice/DiceDetector.py | 21 +++++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)
 create mode 100644 perception/tasks/dice/DiceDetector.py

diff --git a/perception/__init__.py b/perception/__init__.py
index 1a2550b..a755b8d 100644
--- a/perception/__init__.py
+++ b/perception/__init__.py
@@ -7,7 +7,7 @@
 from perception.tasks.segmentation.COMB_SAL_BG import COMB_SAL_BG
 import perception.vis.TestTasks.BackgroundRemoval as BackgroundRemoval
 import perception.tasks.roulette.color_detection as RouletteColorDetector
-# import perception.tasks as tasks
+from perception.tasks.dice.DiceDetector import DiceDetector
 
 ALGOS = {
     'test': TestAlgo.TestAlgo,
@@ -18,5 +18,6 @@
     'MBD': MBD.MBD,
     'bg-rm': BackgroundRemoval.BackgroundRemoval,
     'combined': COMB_SAL_BG,
-    'roulette': RouletteColorDetector.RouletteColorDetector
+    'roulette': RouletteColorDetector.RouletteColorDetector,
+    'dice': DiceDetector
 }
diff --git a/perception/tasks/dice/DiceDetector.py b/perception/tasks/dice/DiceDetector.py
new file mode 100644
index 0000000..ea18cb7
--- /dev/null
+++ b/perception/tasks/dice/DiceDetector.py
@@ -0,0 +1,21 @@
+import cv2 as cv
+import numpy as np
+from perception.tasks.TaskPerceiver import TaskPerceiver
+from typing import Dict
+from perception.tasks.segmentation.COMB_SAL_BG import COMB_SAL_BG
+
+class DiceDetector(TaskPerceiver):
+    def __init__(self, **kwargs):
+        super().__init__(heuristic_threshold=((5,255), 35), run_both=((0,1),0), 
+            centroid_distance_weight=((0,200),1), area_percentage_weight=((0,200),60), num_contours=((1,5), 1))
+        self.sal = COMB_SAL_BG()
+        self.sal.set_num_contours(4)
+        self.sal.use_saliency = False
+        
+    def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
+        contours = self.sal.analyze(frame, False, slider_vals)
+        if len(contours) > 0:
+            for contour in contours:
+                x,y,w,h = cv.boundingRect(contour)
+                cv.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)            
+        return contours, [frame]
\ No newline at end of file

From b7a21cc35c14fe17ee0a2ccab9403385331c88a3 Mon Sep 17 00:00:00 2001
From: Shrey 
Date: Sun, 25 Apr 2021 18:04:38 -0700
Subject: [PATCH 39/43] finalize cleaner version of saliency with "chunks"

---
 .../segmentation/saliency_detection/MBD.py    |   4 +-
 .../prange_saliency_mbd.pyx                   | 144 ++++++++++--------
 requirements.txt                              |   3 +-
 3 files changed, 84 insertions(+), 67 deletions(-)

diff --git a/perception/tasks/segmentation/saliency_detection/MBD.py b/perception/tasks/segmentation/saliency_detection/MBD.py
index df96757..2f1121b 100644
--- a/perception/tasks/segmentation/saliency_detection/MBD.py
+++ b/perception/tasks/segmentation/saliency_detection/MBD.py
@@ -1,5 +1,5 @@
 from perception.tasks.TaskPerceiver import TaskPerceiver
-from perception.tasks.segmentation.saliency_detection.saliency_mbd import get_saliency_mbd
+from perception.tasks.segmentation.saliency_detection.prange_saliency_mbd import get_saliency_mbd
 import numpy as np
 import cv2 as cv
 from typing import Dict
@@ -10,5 +10,5 @@ def __init__(self, **kwargs):
         super().__init__(lower_bound=((0,255), 10))
 
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
-        mbd = get_saliency_mbd(frame).astype('uint8')
+        mbd = get_saliency_mbd(frame,res = 5).astype('uint8')
         return mbd, [frame, mbd]
diff --git a/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx b/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx
index caeaf30..bebd5ab 100644
--- a/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx
+++ b/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx
@@ -14,12 +14,11 @@ np.import_array()
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
+cdef raster_scan(double [:,:] img, double [:,:] L, double [:,:] U, double [:,:] D, int res):
 	# cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double)
 	cdef int n_rows = img.shape[0]
 	cdef int n_cols = img.shape[1]
 	
-	
 	cdef Py_ssize_t x, y
 	cdef double ix
 	cdef double d
@@ -29,17 +28,23 @@ cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, n
 	cdef double l2
 	cdef double b1
 	cdef double b2
-
-	for x in xrange(1,n_rows - 1):
-		for y in xrange(1,n_cols - 1):
-			ix = img[x, y]
-			d = D[x,y]
-
-			u1 = U[x-1,y]
-			l1 = L[x-1,y]
-
-			u2 = U[x,y-1]
-			l2 = L[x,y-1]
+	cdef int r2 = res//2
+	for x in xrange(1,n_rows - res - 1, res):
+		for y in xrange(1,n_cols - res - 1, res):
+			# ix = np.min(img[x:x+res,y:y+res])
+			# d = np.mean(D[x:x+res,y:y+res])
+			ix = img[x+r2,y+r2]
+			d = D[x +r2,y+r2]
+
+			# u1 = np.max(U[x-1:x-1+res,y])
+			# l1 = np.min(L[x-1:x-1+res,y])
+			u1 = U[x-1+r2,y+r2]
+			l1 = L[x-1+r2,y+r2]
+
+			# u2 = np.max(U[x:x+res,y-1:y-1+res])
+			# l2 = np.min(L[x:x+res,y-1:y-1+res])
+			u2 = U[x+r2,y-1+r2]
+			l2 = L[x+r2,y-1+r2]
 
 			b1 = max(u1,ix) - min(l1,ix)
 			b2 = max(u2,ix) - min(l2,ix)
@@ -47,22 +52,22 @@ cdef raster_scan(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, n
 			if d <= b1 and d <= b2:
 				continue
 			elif b1 < d and b1 <= b2:
-				D[x,y] = b1
-				U[x,y] = max(u1,ix)
-				L[x,y] = min(l1,ix)
+				D[x:x+res,y:y+res] = b1
+				U[x:x+res,y:y+res] = max(u1,ix)
+				L[x:x+res,y:y+res] = min(l1,ix)
 			else:
-				D[x,y] = b2
-				U[x,y] = max(u2,ix)
-				L[x,y] = min(l2,ix)
+				D[x:x+res,y:y+res] = b2
+				U[x:x+res,y:y+res] = max(u2,ix)
+				L[x:x+res,y:y+res] = min(l2,ix)
 
 	return True
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2] L, np.ndarray[double, ndim=2] U, np.ndarray[double, ndim=2] D):
+cdef raster_scan_inv(double [:,:] img, double [:,:] L, double [:,:] U, double [:,:] D, int res):
 	cdef int n_rows
 	cdef int n_cols
-
+		
 	n_rows = img.shape[0]
 	n_cols = img.shape[1]
 
@@ -75,18 +80,24 @@ cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2]
 	cdef double l2
 	cdef double b1
 	cdef double b2
-
-	for x in xrange(n_rows - 2,1,-1):
-		for y in xrange(n_cols - 2,1,-1):
+	cdef int r2 = res//2
+	for x in xrange(n_rows - 2 - res,1,-1*res):
+		for y in xrange(n_cols - 2 - res,1,-1*res):
 			
-			ix = img[x,y]
-			d = D[x,y]
+			# ix = np.min(img[x:x+res,y:y+res])
+			# d = np.mean(D[x:x+res,y:y+res])
+			ix = img[x+r2,y+r2]
+			d = D[x +r2,y+r2]
 
-			u1 = U[x+1,y]
-			l1 = L[x+1,y]
+			# u1 = np.max(U[x+1:x+1+res,y:y+res])
+			# l1 = np.min(L[x+1:x+1+res,y:y+res])
+			u1 = U[x+1+r2,y+r2]
+			l1 = L[x+1+r2,y+r2]
 
-			u2 = U[x,y+1]
-			l2 = L[x,y+1]
+			# u2 = np.max(U[x:x+res,y+1:y+1+res])
+			# l2 = np.min(L[x:x+res,y+1:y+1+res])
+			u2 = U[x+r2,y+1+r2]
+			l2 = L[x+r2,y+1+r2]
 
 			b1 = max(u1,ix) - min(l1,ix)
 			b2 = max(u2,ix) - min(l2,ix)
@@ -94,22 +105,21 @@ cdef raster_scan_inv(np.ndarray[double, ndim=2] img, np.ndarray[double, ndim=2]
 			if d <= b1 and d <= b2:
 				continue
 			elif b1 < d and b1 <= b2:
-				D[x,y] = b1
-				U[x,y] = max(u1,ix)
-				L[x,y] = min(l1,ix)
+				D[x:x+res,y:y+res] = b1
+				U[x:x+res,y:y+res] = max(u1,ix)
+				L[x:x+res,y:y+res] = min(l1,ix)
 			else:
-				D[x,y] = b2
-				U[x,y] = max(u2,ix)
-				L[x,y] = min(l2,ix)
+				D[x:x+res,y:y+res] = b2
+				U[x:x+res,y:y+res] = max(u2,ix)
+				L[x:x+res,y:y+res] = min(l2,ix)
 
 	return True
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef mbd(np.ndarray[double, ndim=2] img, int num_iters):
-
-	cdef np.ndarray[double, ndim=2] L = img[...]
-	cdef np.ndarray[double, ndim=2] U = img[...]
+cdef mbd(np.ndarray[double, ndim=2] img, int num_iters, int res):
+	cdef double [:,:] L = img[...]
+	cdef double [:,:] U = img[...]
 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
 	D[0,:] = 0
 	D[-1,:] = 0
@@ -119,9 +129,9 @@ cdef mbd(np.ndarray[double, ndim=2] img, int num_iters):
 	cdef int x
 	for x in xrange(0,num_iters):
 		if x%2 == 1:
-			raster_scan(img,L,U,D)
+			raster_scan(img,L,U,D,res)
 		else:
-			raster_scan_inv(img,L,U,D)
+			raster_scan_inv(img,L,U,D,res)
 
 	return D
 
@@ -138,48 +148,56 @@ cdef f(x):
 
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cpdef get_saliency_mbd(np.ndarray img,method='b'):
+cpdef get_saliency_mbd(np.ndarray img,method='b', res = 2):
 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
 	img_mean = np.mean(img,axis=(2))
-	sal = mbd(img_mean,2)
-
+	sal = mbd(img_mean,2, res)
 	cdef int n_rows = img.shape[0]
 	cdef int n_cols = img.shape[1]
 	cdef int n_channels = img.shape[2]
 	cdef double img_size = sqrt(n_rows * n_cols)
 	cdef border_thickness = int(floor(0.1 * img_size))
-
-	cdef np.ndarray img_lab = img_as_float(skimage.color.rgb2lab(img))
+	cdef np.ndarray[double,ndim=3] img_lab = img_as_float(skimage.color.rgb2lab(img))
 	
 	## Process Left right
-	cdef np.ndarray px_1 = np.zeros((2,border_thickness,img_lab.shape[1], img_lab.shape[2]))
+	cdef np.ndarray[double,ndim=4] px_1 = np.empty((2,border_thickness,img_lab.shape[1], img_lab.shape[2]))
 	px_1[0] = img_lab[0:border_thickness,:,:]
 	px_1[1] = img_lab[n_rows - border_thickness-1:-1,:,:]
 	
 	## Process Top bottom
-	cdef np.ndarray px_2 = np.zeros((2,img_lab.shape[0],border_thickness,img_lab.shape[2]))
+	cdef np.ndarray[double,ndim=4] px_2= np.empty((2,img_lab.shape[0],border_thickness,img_lab.shape[2]))
 	px_2[0] = img_lab[:,0:border_thickness,:]
 	px_2[1] = img_lab[:,n_cols - border_thickness-1:-1,:]
 	
 	## Combine into one array for easy access
-	cdef px = [px_1,px_2]
+	# cdef px = [px_1,px_2]
 	
-	cdef  np.ndarray px_mean = np.zeros((4,3))
-	cdef  np.ndarray cov = np.zeros((4,3,3))
-	cdef px_new = [np.zeros((2, n_cols*border_thickness,3)), np.zeros((2, n_rows*border_thickness,3))]
+	cdef  np.ndarray[double,ndim=2] px_mean = np.empty((4,3)) ## np.ndarray[double,ndim=2]
+	cdef  np.ndarray[double,ndim=3] cov = np.empty((4,3,3))
+	cdef np.ndarray[double,ndim=3] px_new_1 = np.empty((2, n_cols*border_thickness,3))
+	cdef np.ndarray[double,ndim=3] px_new_2  = np.empty((2, n_rows*border_thickness,3))
 	
-	# with multiprocessing.Pool(processes=len(px)) as pool:
-	# 	pool.starmap(mbd_1, (enumerate(zip(px, cov, px_mean)), n_cols, border_thickness))
 	#TODO: work on prange implementation to not use numpy (to circumvent GIL)
+	
+	cdef np.ndarray[double,ndim=4] px 
+	cdef np.ndarray[double,ndim=3] px_new
+	cdef Py_ssize_t x
 	for x in xrange(4):
-		px_mean[x] = np.mean(px[x//2][x%2],axis=(0,1))
-		px_new[x//2][x%2] = px[x//2][x%2].reshape(((n_cols if x//2 == 0 else n_rows)*border_thickness,3))
-		cov[x] =  np.linalg.inv(np.cov(px_new[x//2][x%2].T))
+		if x//2 == 0:
+			px = px_1  
+			px_new = px_new_1
+		else:
+			px = px_2
+			px_new = px_new_2 
+		px_mean[x] = np.mean(px[x%2],axis=(0,1))
+		px_new[x%2] = px[x%2].reshape(((n_cols if x//2 == 0 else n_rows)*border_thickness,3))
+		cov[x] =  np.linalg.inv(np.cov(px_new[x%2].T))
+		
 
-	u = np.zeros((4,img_lab.shape[0],img_lab.shape[1]), dtype=np.float)
+	cdef np.ndarray[double,ndim=3] u = np.empty((4,img_lab.shape[0],img_lab.shape[1]))
 
-	img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)
-	px_mean_2 = np.zeros((4,1,3), dtype=np.float)
+	cdef np.ndarray[double,ndim=2] img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)
+	cdef np.ndarray[double,ndim=3] px_mean_2 = np.empty((4,1,3))
 	for x in xrange(4):
 		px_mean_2[x,0] = px_mean[x]
 		u[x] = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_2[x],'mahalanobis', VI=cov[x]).reshape((img_lab.shape[0],img_lab.shape[1]))
@@ -189,7 +207,7 @@ cpdef get_saliency_mbd(np.ndarray img,method='b'):
 	u_max = np.maximum(np.maximum(u[0],u[1]),np.maximum(u[2],u[3]))
 
 	u_final = np.sum (u,axis = 0) - u_max
-
+	
 	u_max_final = np.max(u_final)
 	sal_max = np.max(sal)
 	sal = sal / sal_max + u_final / u_max_final
@@ -198,11 +216,9 @@ cpdef get_saliency_mbd(np.ndarray img,method='b'):
 
 	# apply centredness map
 	sal = sal / np.max(sal)
-	
 	s = np.mean(sal)
 	cdef double alpha = 50.0
 	cdef double delta = alpha * sqrt(s)
-
 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))
 	cdef int w = sal.shape[0]
 	cdef int h = sal.shape[1]
diff --git a/requirements.txt b/requirements.txt
index 6f61337..bebe3ca 100755
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,4 +5,5 @@ matplotlib
 imageio
 imageio-ffmpeg
 pytest
-cython
\ No newline at end of file
+cython
+scikit-image

From b04623cb28fed8ffa3f7e38f93200174ebf33eed Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 6 Jun 2021 12:13:03 -0700
Subject: [PATCH 40/43] Added Rectangle interpolator

---
 perception/tasks/dice/DiceDetector.py         |    32 +-
 .../saliency_detection/prange_saliency_mbd.c  | 31074 ++++++++++++++++
 2 files changed, 31103 insertions(+), 3 deletions(-)
 create mode 100644 perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.c

diff --git a/perception/tasks/dice/DiceDetector.py b/perception/tasks/dice/DiceDetector.py
index ea18cb7..a54cd0a 100644
--- a/perception/tasks/dice/DiceDetector.py
+++ b/perception/tasks/dice/DiceDetector.py
@@ -3,19 +3,45 @@
 from perception.tasks.TaskPerceiver import TaskPerceiver
 from typing import Dict
 from perception.tasks.segmentation.COMB_SAL_BG import COMB_SAL_BG
+import queue
 
 class DiceDetector(TaskPerceiver):
     def __init__(self, **kwargs):
         super().__init__(heuristic_threshold=((5,255), 35), run_both=((0,1),0), 
             centroid_distance_weight=((0,200),1), area_percentage_weight=((0,200),60), num_contours=((1,5), 1))
         self.sal = COMB_SAL_BG()
-        self.sal.set_num_contours(4)
+        self.sal.set_num_contours(1)
         self.sal.use_saliency = False
+        self.interpolator = RectangleInterpolator(20)
         
     def analyze(self, frame: np.ndarray, debug: bool, slider_vals: Dict[str, int]):
         contours = self.sal.analyze(frame, False, slider_vals)
         if len(contours) > 0:
             for contour in contours:
                 x,y,w,h = cv.boundingRect(contour)
-                cv.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)            
-        return contours, [frame]
\ No newline at end of file
+                cv.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)
+                self.interpolator.insert_new_rectangle(x, y, w, h)
+        avg_coord1, avg_coord2 = self.interpolator.get_avg_coordinates()
+        cv.rectangle(frame,avg_coord1,avg_coord2,(255,0,255),2)
+        return contours, [frame]
+
+class RectangleInterpolator():
+
+    def __init__(self, num_rectangles):
+        self.contour_queue = queue.Queue(maxsize=num_rectangles)
+        self.coord1Sum = (0, 0)
+        self.coord2Sum = (0, 0)
+
+    def insert_new_rectangle(self, x, y, w, h):
+        if self.contour_queue.full():
+            value = self.contour_queue.get()
+            self.coord1Sum = (self.coord1Sum[0] - value[0][0], self.coord1Sum[1] - value[0][1])
+            self.coord2Sum = (self.coord2Sum[0] - value[1][0], self.coord2Sum[1] - value[1][1])
+        self.contour_queue.put([(x, y), (x+w, y+h)])
+        self.coord1Sum = (self.coord1Sum[0] + x, self.coord1Sum[1] + y)
+        self.coord2Sum = (self.coord2Sum[0] + x + w, self.coord2Sum[1] + y + h)
+    
+    def get_avg_coordinates(self):
+        avg_coord1 = (int(self.coord1Sum[0] / self.contour_queue.qsize()), int(self.coord1Sum[1] / self.contour_queue.qsize()))
+        avg_coord2 = (int(self.coord2Sum[0] / self.contour_queue.qsize()), int(self.coord2Sum[1] / self.contour_queue.qsize()))
+        return avg_coord1, avg_coord2
\ No newline at end of file
diff --git a/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.c b/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.c
new file mode 100644
index 0000000..7f95906
--- /dev/null
+++ b/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.c
@@ -0,0 +1,31074 @@
+/* Generated by Cython 0.29.21 */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#ifndef Py_PYTHON_H
+    #error Python headers needed to compile C extensions, please install development version of Python.
+#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.6+ or Python 3.3+.
+#else
+#define CYTHON_ABI "0_29_21"
+#define CYTHON_HEX_VERSION 0x001D15F0
+#define CYTHON_FUTURE_DIVISION 0
+#include 
+#ifndef offsetof
+  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+#endif
+#if !defined(WIN32) && !defined(MS_WINDOWS)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#define __PYX_COMMA ,
+#ifndef HAVE_LONG_LONG
+  #if PY_VERSION_HEX >= 0x02070000
+    #define HAVE_LONG_LONG
+  #endif
+#endif
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#ifndef Py_HUGE_VAL
+  #define Py_HUGE_VAL HUGE_VAL
+#endif
+#ifdef PYPY_VERSION
+  #define CYTHON_COMPILING_IN_PYPY 1
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #undef CYTHON_PEP489_MULTI_PHASE_INIT
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+#elif defined(PYSTON_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #undef CYTHON_PEP489_MULTI_PHASE_INIT
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #if PY_VERSION_HEX < 0x02070000
+    #undef CYTHON_USE_PYTYPE_LOOKUP
+    #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+    #define CYTHON_USE_PYTYPE_LOOKUP 1
+  #endif
+  #if PY_MAJOR_VERSION < 3
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #if PY_VERSION_HEX < 0x02070000
+    #undef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if PY_VERSION_HEX < 0x030300F0
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #endif
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #endif
+  #ifndef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #endif
+  #ifndef CYTHON_USE_EXC_INFO_STACK
+    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+  #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #include "longintrepr.h"
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+  #ifdef SIZEOF_VOID_P
+    enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
+  #endif
+#endif
+#ifndef __has_attribute
+  #define __has_attribute(x) 0
+#endif
+#ifndef __has_cpp_attribute
+  #define __has_cpp_attribute(x) 0
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+#  if defined(__cplusplus)
+     template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# endif
+#endif
+#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
+#ifdef _MSC_VER
+    #ifndef _MSC_STDINT_H_
+        #if _MSC_VER < 1300
+           typedef unsigned char     uint8_t;
+           typedef unsigned int      uint32_t;
+        #else
+           typedef unsigned __int8   uint8_t;
+           typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+#else
+   #include 
+#endif
+#ifndef CYTHON_FALLTHROUGH
+  #if defined(__cplusplus) && __cplusplus >= 201103L
+    #if __has_cpp_attribute(fallthrough)
+      #define CYTHON_FALLTHROUGH [[fallthrough]]
+    #elif __has_cpp_attribute(clang::fallthrough)
+      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+    #elif __has_cpp_attribute(gnu::fallthrough)
+      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+    #endif
+  #endif
+  #ifndef CYTHON_FALLTHROUGH
+    #if __has_attribute(fallthrough)
+      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
+    #else
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+  #if defined(__clang__ ) && defined(__apple_build_version__)
+    #if __apple_build_version__ < 7000000
+      #undef  CYTHON_FALLTHROUGH
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+#endif
+
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #elif defined(__GNUC__)
+    #define CYTHON_INLINE __inline__
+  #elif defined(_MSC_VER)
+    #define CYTHON_INLINE __inline
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_INLINE inline
+  #else
+    #define CYTHON_INLINE
+  #endif
+#endif
+
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+  #define Py_OptimizeFlag 0
+#endif
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyClass_Type
+#else
+  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#else
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#endif
+  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_STACKLESS
+  #define METH_STACKLESS 0
+#endif
+#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
+  #ifndef METH_FASTCALL
+     #define METH_FASTCALL 0x80
+  #endif
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
+  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
+                                                          Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+#endif
+#if CYTHON_FAST_PYCCALL
+#define __Pyx_PyFastCFunction_Check(func)\
+    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+  #define PyObject_Malloc(s)   PyMem_Malloc(s)
+  #define PyObject_Free(p)     PyMem_Free(p)
+  #define PyObject_Realloc(p)  PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
+  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
+  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
+  #define PyMem_RawFree(p)             PyMem_Free(p)
+#endif
+#if CYTHON_COMPILING_IN_PYSTON
+  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#else
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
+#endif
+#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x03060000
+  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
+#elif PY_VERSION_HEX >= 0x03000000
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#else
+  #define __Pyx_PyThreadState_Current _PyThreadState_Current
+#endif
+#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
+#include "pythread.h"
+#define Py_tss_NEEDS_INIT 0
+typedef int Py_tss_t;
+static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
+  *key = PyThread_create_key();
+  return 0;
+}
+static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
+  Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
+  *key = Py_tss_NEEDS_INIT;
+  return key;
+}
+static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
+  PyObject_Free(key);
+}
+static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
+  return *key != Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
+  PyThread_delete_key(*key);
+  *key = Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
+  return PyThread_set_key_value(*key, value);
+}
+static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
+  return PyThread_get_key_value(*key);
+}
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
+#else
+#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
+#endif
+#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#else
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#else
+#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                              0 : _PyUnicode_Ready((PyObject *)(op)))
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
+  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
+  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+  #else
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+  #endif
+#else
+  #define CYTHON_PEP393_ENABLED 0
+  #define PyUnicode_1BYTE_KIND  1
+  #define PyUnicode_2BYTE_KIND  2
+  #define PyUnicode_4BYTE_KIND  4
+  #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
+  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
+  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
+  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
+  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#endif
+#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
+#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#else
+  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBaseString_Type            PyUnicode_Type
+  #define PyStringObject               PyUnicodeObject
+  #define PyString_Type                PyUnicode_Type
+  #define PyString_Check               PyUnicode_Check
+  #define PyString_CheckExact          PyUnicode_CheckExact
+#ifndef PyObject_Unicode
+  #define PyObject_Unicode             PyObject_Str
+#endif
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#endif
+#if PY_VERSION_HEX >= 0x030900A4
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
+#else
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
+#endif
+#if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+#else
+  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyIntObject                  PyLongObject
+  #define PyInt_Type                   PyLong_Type
+  #define PyInt_Check(op)              PyLong_Check(op)
+  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define PyInt_FromString             PyLong_FromString
+  #define PyInt_FromUnicode            PyLong_FromUnicode
+  #define PyInt_FromLong               PyLong_FromLong
+  #define PyInt_FromSize_t             PyLong_FromSize_t
+  #define PyInt_FromSsize_t            PyLong_FromSsize_t
+  #define PyInt_AsLong                 PyLong_AsLong
+  #define PyInt_AS_LONG                PyLong_AS_LONG
+  #define PyInt_AsSsize_t              PyLong_AsSsize_t
+  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
+  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+  #define PyNumber_Int                 PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBoolObject                 PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+  #ifndef PyUnicode_InternFromString
+    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+  #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+  typedef long Py_hash_t;
+  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
+#else
+  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
+#else
+  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
+#endif
+#if CYTHON_USE_ASYNC_SLOTS
+  #if PY_VERSION_HEX >= 0x030500B1
+    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+  #else
+    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+  #endif
+#else
+  #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef __Pyx_PyAsyncMethodsStruct
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+    } __Pyx_PyAsyncMethodsStruct;
+#endif
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+  #define _USE_MATH_DEFINES
+#endif
+#include 
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+  float value;
+  memset(&value, 0xFF, sizeof(value));
+  return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+#define __PYX_MARK_ERR_POS(f_index, lineno) \
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__prange_saliency_mbd
+#define __PYX_HAVE_API__prange_saliency_mbd
+/* Early includes */
+#include 
+#include 
+#include "numpy/arrayobject.h"
+#include "numpy/ufuncobject.h"
+#include 
+#include "pythread.h"
+#include 
+#include "pystate.h"
+#ifdef _OPENMP
+#include 
+#endif /* _OPENMP */
+
+#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
+    return (size_t) i < (size_t) limit;
+}
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include 
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER)
+    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
+    const Py_UNICODE *u_end = u;
+    while (*u_end++) ;
+    return (size_t)(u_end - u - 1);
+}
+#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
+#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+#define __Pyx_PySequence_Tuple(obj)\
+    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    PyObject* ascii_chars_u = NULL;
+    PyObject* ascii_chars_b = NULL;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
+
+static PyObject *__pyx_m = NULL;
+static PyObject *__pyx_d;
+static PyObject *__pyx_b;
+static PyObject *__pyx_cython_runtime = NULL;
+static PyObject *__pyx_empty_tuple;
+static PyObject *__pyx_empty_bytes;
+static PyObject *__pyx_empty_unicode;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+/* Header.proto */
+#if !defined(CYTHON_CCOMPLEX)
+  #if defined(__cplusplus)
+    #define CYTHON_CCOMPLEX 1
+  #elif defined(_Complex_I)
+    #define CYTHON_CCOMPLEX 1
+  #else
+    #define CYTHON_CCOMPLEX 0
+  #endif
+#endif
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #include 
+  #else
+    #include 
+  #endif
+#endif
+#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
+  #undef _Complex_I
+  #define _Complex_I 1.0fj
+#endif
+
+
+static const char *__pyx_f[] = {
+  "prange_saliency_mbd.pyx",
+  "__init__.pxd",
+  "stringsource",
+  "type.pxd",
+};
+/* MemviewSliceStruct.proto */
+struct __pyx_memoryview_obj;
+typedef struct {
+  struct __pyx_memoryview_obj *memview;
+  char *data;
+  Py_ssize_t shape[8];
+  Py_ssize_t strides[8];
+  Py_ssize_t suboffsets[8];
+} __Pyx_memviewslice;
+#define __Pyx_MemoryView_Len(m)  (m.shape[0])
+
+/* Atomics.proto */
+#include 
+#ifndef CYTHON_ATOMICS
+    #define CYTHON_ATOMICS 1
+#endif
+#define __pyx_atomic_int_type int
+#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||\
+                    (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) &&\
+                    !defined(__i386__)
+    #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1)
+    #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1)
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Using GNU atomics"
+    #endif
+#elif CYTHON_ATOMICS && defined(_MSC_VER) && 0
+    #include 
+    #undef __pyx_atomic_int_type
+    #define __pyx_atomic_int_type LONG
+    #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value)
+    #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value)
+    #ifdef __PYX_DEBUG_ATOMICS
+        #pragma message ("Using MSVC atomics")
+    #endif
+#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0
+    #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value)
+    #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value)
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Using Intel atomics"
+    #endif
+#else
+    #undef CYTHON_ATOMICS
+    #define CYTHON_ATOMICS 0
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Not using atomics"
+    #endif
+#endif
+typedef volatile __pyx_atomic_int_type __pyx_atomic_int;
+#if CYTHON_ATOMICS
+    #define __pyx_add_acquisition_count(memview)\
+             __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
+    #define __pyx_sub_acquisition_count(memview)\
+            __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
+#else
+    #define __pyx_add_acquisition_count(memview)\
+            __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
+    #define __pyx_sub_acquisition_count(memview)\
+            __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
+#endif
+
+/* BufferFormatStructs.proto */
+#define IS_UNSIGNED(type) (((type) -1) > 0)
+struct __Pyx_StructField_;
+#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
+typedef struct {
+  const char* name;
+  struct __Pyx_StructField_* fields;
+  size_t size;
+  size_t arraysize[8];
+  int ndim;
+  char typegroup;
+  char is_unsigned;
+  int flags;
+} __Pyx_TypeInfo;
+typedef struct __Pyx_StructField_ {
+  __Pyx_TypeInfo* type;
+  const char* name;
+  size_t offset;
+} __Pyx_StructField;
+typedef struct {
+  __Pyx_StructField* field;
+  size_t parent_offset;
+} __Pyx_BufFmt_StackElem;
+typedef struct {
+  __Pyx_StructField root;
+  __Pyx_BufFmt_StackElem* head;
+  size_t fmt_offset;
+  size_t new_count, enc_count;
+  size_t struct_alignment;
+  int is_complex;
+  char enc_type;
+  char new_packmode;
+  char enc_packmode;
+  char is_valid_array;
+} __Pyx_BufFmt_Context;
+
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
+/* NoFastGil.proto */
+#define __Pyx_PyGILState_Ensure PyGILState_Ensure
+#define __Pyx_PyGILState_Release PyGILState_Release
+#define __Pyx_FastGIL_Remember()
+#define __Pyx_FastGIL_Forget()
+#define __Pyx_FastGilFuncInit()
+
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":775
+ * # in Cython to enable them only on the right systems.
+ * 
+ * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ */
+typedef npy_int8 __pyx_t_5numpy_int8_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ * 
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t
+ */
+typedef npy_int16 __pyx_t_5numpy_int16_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int64      int64_t
+ * #ctypedef npy_int96      int96_t
+ */
+typedef npy_int32 __pyx_t_5numpy_int32_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_int96      int96_t
+ * #ctypedef npy_int128     int128_t
+ */
+typedef npy_int64 __pyx_t_5numpy_int64_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ * #ctypedef npy_int128     int128_t
+ * 
+ * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ */
+typedef npy_uint8 __pyx_t_5numpy_uint8_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783
+ * 
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t
+ */
+typedef npy_uint16 __pyx_t_5numpy_uint16_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint64     uint64_t
+ * #ctypedef npy_uint96     uint96_t
+ */
+typedef npy_uint32 __pyx_t_5numpy_uint32_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_uint96     uint96_t
+ * #ctypedef npy_uint128    uint128_t
+ */
+typedef npy_uint64 __pyx_t_5numpy_uint64_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":789
+ * #ctypedef npy_uint128    uint128_t
+ * 
+ * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_float64    float64_t
+ * #ctypedef npy_float80    float80_t
+ */
+typedef npy_float32 __pyx_t_5numpy_float32_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790
+ * 
+ * ctypedef npy_float32    float32_t
+ * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_float80    float80_t
+ * #ctypedef npy_float128   float128_t
+ */
+typedef npy_float64 __pyx_t_5numpy_float64_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * # The int types are mapped a bit surprising --
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t
+ */
+typedef npy_long __pyx_t_5numpy_int_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   longlong_t
+ * 
+ */
+typedef npy_longlong __pyx_t_5numpy_long_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_ulong      uint_t
+ */
+typedef npy_longlong __pyx_t_5numpy_longlong_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ * ctypedef npy_longlong   longlong_t
+ * 
+ * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t
+ */
+typedef npy_ulong __pyx_t_5numpy_uint_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804
+ * 
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_intp       intp_t
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":807
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uintp      uintp_t
+ * 
+ */
+typedef npy_intp __pyx_t_5numpy_intp_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808
+ * 
+ * ctypedef npy_intp       intp_t
+ * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_double     float_t
+ */
+typedef npy_uintp __pyx_t_5numpy_uintp_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":810
+ * ctypedef npy_uintp      uintp_t
+ * 
+ * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t
+ */
+typedef npy_double __pyx_t_5numpy_float_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811
+ * 
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ */
+typedef npy_double __pyx_t_5numpy_double_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ */
+typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< float > __pyx_t_float_complex;
+  #else
+    typedef float _Complex __pyx_t_float_complex;
+  #endif
+#else
+    typedef struct { float real, imag; } __pyx_t_float_complex;
+#endif
+static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);
+
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< double > __pyx_t_double_complex;
+  #else
+    typedef double _Complex __pyx_t_double_complex;
+  #endif
+#else
+    typedef struct { double real, imag; } __pyx_t_double_complex;
+#endif
+static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);
+
+
+/*--- Type declarations ---*/
+struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py;
+struct __pyx_array_obj;
+struct __pyx_MemviewEnum_obj;
+struct __pyx_memoryview_obj;
+struct __pyx_memoryviewslice_obj;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":814
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t
+ */
+typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ */
+typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cdouble     complex_t
+ */
+typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":818
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ */
+typedef npy_cdouble __pyx_t_5numpy_complex_t;
+struct __pyx_opt_args_19prange_saliency_mbd_get_saliency_mbd;
+
+/* "prange_saliency_mbd.pyx":151
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef get_saliency_mbd(np.ndarray img,method='b', res = 2):             # <<<<<<<<<<<<<<
+ * 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
+ * 	img_mean = np.mean(img,axis=(2))
+ */
+struct __pyx_opt_args_19prange_saliency_mbd_get_saliency_mbd {
+  int __pyx_n;
+  PyObject *method;
+  PyObject *res;
+};
+
+/* "cfunc.to_py":64
+ * 
+ * @cname("__Pyx_CFunc_object____object___to_py")
+ * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ):             # <<<<<<<<<<<<<<
+ *     def wrap(object x):
+ *         """wrap(x)"""
+ */
+struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py {
+  PyObject_HEAD
+  PyObject *(*__pyx_v_f)(PyObject *);
+};
+
+
+/* "View.MemoryView":105
+ * 
+ * @cname("__pyx_array")
+ * cdef class array:             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+struct __pyx_array_obj {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_array *__pyx_vtab;
+  char *data;
+  Py_ssize_t len;
+  char *format;
+  int ndim;
+  Py_ssize_t *_shape;
+  Py_ssize_t *_strides;
+  Py_ssize_t itemsize;
+  PyObject *mode;
+  PyObject *_format;
+  void (*callback_free_data)(void *);
+  int free_data;
+  int dtype_is_object;
+};
+
+
+/* "View.MemoryView":279
+ * 
+ * @cname('__pyx_MemviewEnum')
+ * cdef class Enum(object):             # <<<<<<<<<<<<<<
+ *     cdef object name
+ *     def __init__(self, name):
+ */
+struct __pyx_MemviewEnum_obj {
+  PyObject_HEAD
+  PyObject *name;
+};
+
+
+/* "View.MemoryView":330
+ * 
+ * @cname('__pyx_memoryview')
+ * cdef class memoryview(object):             # <<<<<<<<<<<<<<
+ * 
+ *     cdef object obj
+ */
+struct __pyx_memoryview_obj {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_memoryview *__pyx_vtab;
+  PyObject *obj;
+  PyObject *_size;
+  PyObject *_array_interface;
+  PyThread_type_lock lock;
+  __pyx_atomic_int acquisition_count[2];
+  __pyx_atomic_int *acquisition_count_aligned_p;
+  Py_buffer view;
+  int flags;
+  int dtype_is_object;
+  __Pyx_TypeInfo *typeinfo;
+};
+
+
+/* "View.MemoryView":965
+ * 
+ * @cname('__pyx_memoryviewslice')
+ * cdef class _memoryviewslice(memoryview):             # <<<<<<<<<<<<<<
+ *     "Internal class for passing memoryview slices to Python"
+ * 
+ */
+struct __pyx_memoryviewslice_obj {
+  struct __pyx_memoryview_obj __pyx_base;
+  __Pyx_memviewslice from_slice;
+  PyObject *from_object;
+  PyObject *(*to_object_func)(char *);
+  int (*to_dtype_func)(char *, PyObject *);
+};
+
+
+
+/* "View.MemoryView":105
+ * 
+ * @cname("__pyx_array")
+ * cdef class array:             # <<<<<<<<<<<<<<
+ * 
+ *     cdef:
+ */
+
+struct __pyx_vtabstruct_array {
+  PyObject *(*get_memview)(struct __pyx_array_obj *);
+};
+static struct __pyx_vtabstruct_array *__pyx_vtabptr_array;
+
+
+/* "View.MemoryView":330
+ * 
+ * @cname('__pyx_memoryview')
+ * cdef class memoryview(object):             # <<<<<<<<<<<<<<
+ * 
+ *     cdef object obj
+ */
+
+struct __pyx_vtabstruct_memoryview {
+  char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *);
+  PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *);
+  PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
+  PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *);
+  PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *);
+  PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *);
+  PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *);
+};
+static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview;
+
+
+/* "View.MemoryView":965
+ * 
+ * @cname('__pyx_memoryviewslice')
+ * cdef class _memoryviewslice(memoryview):             # <<<<<<<<<<<<<<
+ *     "Internal class for passing memoryview slices to Python"
+ * 
+ */
+
+struct __pyx_vtabstruct__memoryviewslice {
+  struct __pyx_vtabstruct_memoryview __pyx_base;
+};
+static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice;
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+  typedef struct {
+    void (*INCREF)(void*, PyObject*, int);
+    void (*DECREF)(void*, PyObject*, int);
+    void (*GOTREF)(void*, PyObject*, int);
+    void (*GIVEREF)(void*, PyObject*, int);
+    void* (*SetupContext)(const char*, int, const char*);
+    void (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+          }
+#else
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+  #define __Pyx_RefNannyFinishContext()\
+          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* None.proto */
+static CYTHON_INLINE long __Pyx_div_long(long, long);
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* MemviewSliceInit.proto */
+#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d
+#define __Pyx_MEMVIEW_DIRECT   1
+#define __Pyx_MEMVIEW_PTR      2
+#define __Pyx_MEMVIEW_FULL     4
+#define __Pyx_MEMVIEW_CONTIG   8
+#define __Pyx_MEMVIEW_STRIDED  16
+#define __Pyx_MEMVIEW_FOLLOW   32
+#define __Pyx_IS_C_CONTIG 1
+#define __Pyx_IS_F_CONTIG 2
+static int __Pyx_init_memviewslice(
+                struct __pyx_memoryview_obj *memview,
+                int ndim,
+                __Pyx_memviewslice *memviewslice,
+                int memview_is_new_reference);
+static CYTHON_INLINE int __pyx_add_acquisition_count_locked(
+    __pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
+static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(
+    __pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
+#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p)
+#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview))
+#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__)
+#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__)
+static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int);
+static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int);
+
+/* IsLittleEndian.proto */
+static CYTHON_INLINE int __Pyx_Is_Little_Endian(void);
+
+/* BufferFormatCheck.proto */
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type);
+
+/* BufferGetAndValidate.proto */
+#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\
+    ((obj == Py_None || obj == NULL) ?\
+    (__Pyx_ZeroBuffer(buf), 0) :\
+    __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack))
+static int  __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
+    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
+static void __Pyx_ZeroBuffer(Py_buffer* buf);
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
+static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 };
+static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+/* GetItemInt.proto */
+#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
+    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
+               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
+#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              int wraparound, int boundscheck);
+#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              int wraparound, int boundscheck);
+static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
+                                                     int is_list, int wraparound, int boundscheck);
+
+/* ObjectGetItem.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key);
+#else
+#define __Pyx_PyObject_GetItem(obj, key)  PyObject_GetItem(obj, key)
+#endif
+
+/* PyDictVersioning.proto */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
+#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
+    (version_var) = __PYX_GET_DICT_VERSION(dict);\
+    (cache_var) = (value);
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
+    static PY_UINT64_T __pyx_dict_version = 0;\
+    static PyObject *__pyx_dict_cached_value = NULL;\
+    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
+        (VAR) = __pyx_dict_cached_value;\
+    } else {\
+        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
+        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
+    }\
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
+#else
+#define __PYX_GET_DICT_VERSION(dict)  (0)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
+#endif
+
+/* GetModuleGlobalName.proto */
+#if CYTHON_USE_DICT_VERSIONS
+#define __Pyx_GetModuleGlobalName(var, name)  {\
+    static PY_UINT64_T __pyx_dict_version = 0;\
+    static PyObject *__pyx_dict_cached_value = NULL;\
+    (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
+        (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
+        __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+}
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
+    PY_UINT64_T __pyx_dict_version;\
+    PyObject *__pyx_dict_cached_value;\
+    (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+}
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
+#else
+#define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#else
+#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()\
+    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+  #define __Pyx_PyFrame_GetLocalsplus(frame)\
+    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+
+/* PyCFunctionFastCall.proto */
+#if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
+#else
+#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
+#endif
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* None.proto */
+static CYTHON_INLINE long __Pyx_mod_long(long, long);
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* IterFinish.proto */
+static CYTHON_INLINE int __Pyx_IterFinish(void);
+
+/* UnpackItemEndCheck.proto */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
+
+/* PyObjectCall2Args.proto */
+static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyFloatBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check);
+#else
+#define __Pyx_PyFloat_SubtractObjC(op1, op2, floatval, inplace, zerodivision_check)\
+    (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2))
+#endif
+
+/* PyIntFromDouble.proto */
+#if PY_MAJOR_VERSION < 3
+static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value);
+#else
+#define __Pyx_PyInt_FromDouble(value) PyLong_FromDouble(value)
+#endif
+
+/* SetItemInt.proto */
+#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
+    (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
+               __Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
+static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
+                                               int is_list, int wraparound, int boundscheck);
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
+#else
+#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\
+    (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2))
+#endif
+
+/* None.proto */
+static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t);
+
+/* BufferFallbackError.proto */
+static void __Pyx_RaiseBufferFallbackError(void);
+
+/* None.proto */
+static CYTHON_INLINE Py_ssize_t __Pyx_mod_Py_ssize_t(Py_ssize_t, Py_ssize_t);
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
+#else
+#define __Pyx_PyInt_SubtractCObj(op1, op2, intval, inplace, zerodivision_check)\
+    (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2))
+#endif
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+    const char* function_name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* ArgTypeTest.proto */
+#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
+    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+        __Pyx__ArgTypeTest(obj, type, name, exact))
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* DictGetItem.proto */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
+#define __Pyx_PyObject_Dict_GetItem(obj, name)\
+    (likely(PyDict_CheckExact(obj)) ?\
+     __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name))
+#else
+#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
+#define __Pyx_PyObject_Dict_GetItem(obj, name)  PyObject_GetItem(obj, name)
+#endif
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* GetTopmostException.proto */
+#if CYTHON_USE_EXC_INFO_STACK
+static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
+#endif
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* FetchCommonType.proto */
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED 1
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#define __Pyx_CyFunction_GetClassObj(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+    PyCFunctionObject func;
+#if PY_VERSION_HEX < 0x030500A0
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+    PyObject *func_classobj;
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;  // used by FusedFunction for copying defaults
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+} __pyx_CyFunctionObject;
+static PyTypeObject *__pyx_CyFunctionType = 0;
+#define __Pyx_CyFunction_Check(obj)  (__Pyx_TypeCheck(obj, __pyx_CyFunctionType))
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *self,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(void);
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
+/* IncludeStringH.proto */
+#include 
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* StrEquals.proto */
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
+#else
+#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
+#endif
+
+/* UnaryNegOverflows.proto */
+#define UNARY_NEG_WOULD_OVERFLOW(x)\
+        (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))
+
+static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/
+/* GetAttr.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
+
+/* decode_c_string_utf16.proto */
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = 0;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = -1;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) {
+    int byteorder = 1;
+    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
+}
+
+/* decode_c_string.proto */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
+         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
+
+/* GetAttr3.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
+
+/* SwapException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSwap(type, value, tb)  __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* FastTypeChecks.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
+#else
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
+#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
+#endif
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+
+static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+/* ListCompAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len)) {
+        Py_INCREF(x);
+        PyList_SET_ITEM(list, len, x);
+        __Pyx_SET_SIZE(list, len + 1);
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
+#else
+#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\
+    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
+#endif
+
+/* ListExtend.proto */
+static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) {
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject* none = _PyList_Extend((PyListObject*)L, v);
+    if (unlikely(!none))
+        return -1;
+    Py_DECREF(none);
+    return 0;
+#else
+    return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v);
+#endif
+}
+
+/* ListAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
+        Py_INCREF(x);
+        PyList_SET_ITEM(list, len, x);
+        __Pyx_SET_SIZE(list, len + 1);
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* None.proto */
+static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
+
+/* ImportFrom.proto */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
+
+/* HasAttr.proto */
+static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *);
+
+/* PyObject_GenericGetAttrNoDict.proto */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
+#endif
+
+/* PyObject_GenericGetAttr.proto */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
+#endif
+
+/* SetVTable.proto */
+static int __Pyx_SetVtable(PyObject *dict, void *vtable);
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* SetupReduce.proto */
+static int __Pyx_setup_reduce(PyObject* type_obj);
+
+/* TypeImport.proto */
+#ifndef __PYX_HAVE_RT_ImportType_proto
+#define __PYX_HAVE_RT_ImportType_proto
+enum __Pyx_ImportType_CheckSize {
+   __Pyx_ImportType_CheckSize_Error = 0,
+   __Pyx_ImportType_CheckSize_Warn = 1,
+   __Pyx_ImportType_CheckSize_Ignore = 2
+};
+static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+#endif
+
+/* CLineInTraceback.proto */
+#ifdef CYTHON_CLINE_IN_TRACEBACK
+#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
+#else
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
+#endif
+
+/* CodeObjectCache.proto */
+typedef struct {
+    PyCodeObject* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static PyCodeObject *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename);
+
+#if PY_MAJOR_VERSION < 3
+    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
+    static void __Pyx_ReleaseBuffer(Py_buffer *view);
+#else
+    #define __Pyx_GetBuffer PyObject_GetBuffer
+    #define __Pyx_ReleaseBuffer PyBuffer_Release
+#endif
+
+
+/* BufferStructDeclare.proto */
+typedef struct {
+  Py_ssize_t shape, strides, suboffsets;
+} __Pyx_Buf_DimInfo;
+typedef struct {
+  size_t refcount;
+  Py_buffer pybuffer;
+} __Pyx_Buffer;
+typedef struct {
+  __Pyx_Buffer *rcbuffer;
+  char *data;
+  __Pyx_Buf_DimInfo diminfo[8];
+} __Pyx_LocalBuf_ND;
+
+/* MemviewSliceIsContig.proto */
+static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim);
+
+/* OverlappingSlices.proto */
+static int __pyx_slices_overlap(__Pyx_memviewslice *slice1,
+                                __Pyx_memviewslice *slice2,
+                                int ndim, size_t itemsize);
+
+/* Capsule.proto */
+static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value);
+
+/* RealImag.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #define __Pyx_CREAL(z) ((z).real())
+    #define __Pyx_CIMAG(z) ((z).imag())
+  #else
+    #define __Pyx_CREAL(z) (__real__(z))
+    #define __Pyx_CIMAG(z) (__imag__(z))
+  #endif
+#else
+    #define __Pyx_CREAL(z) ((z).real)
+    #define __Pyx_CIMAG(z) ((z).imag)
+#endif
+#if defined(__cplusplus) && CYTHON_CCOMPLEX\
+        && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
+    #define __Pyx_SET_CREAL(z,x) ((z).real(x))
+    #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
+#else
+    #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
+    #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_float(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_float(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_float(a, b) ((a)-(b))
+    #define __Pyx_c_prod_float(a, b) ((a)*(b))
+    #define __Pyx_c_quot_float(a, b) ((a)/(b))
+    #define __Pyx_c_neg_float(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_float(z) ((z)==(float)0)
+    #define __Pyx_c_conj_float(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (::std::abs(z))
+        #define __Pyx_c_pow_float(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_float(z) ((z)==0)
+    #define __Pyx_c_conj_float(z)    (conjf(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (cabsf(z))
+        #define __Pyx_c_pow_float(a, b)  (cpowf(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex);
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex);
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    #endif
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_double(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_double(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_double(a, b) ((a)-(b))
+    #define __Pyx_c_prod_double(a, b) ((a)*(b))
+    #define __Pyx_c_quot_double(a, b) ((a)/(b))
+    #define __Pyx_c_neg_double(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_double(z) ((z)==(double)0)
+    #define __Pyx_c_conj_double(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (::std::abs(z))
+        #define __Pyx_c_pow_double(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_double(z) ((z)==0)
+    #define __Pyx_c_conj_double(z)    (conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (cabs(z))
+        #define __Pyx_c_pow_double(a, b)  (cpow(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex);
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex);
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    #endif
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);
+
+/* MemviewSliceCopyTemplate.proto */
+static __Pyx_memviewslice
+__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
+                                 const char *mode, int ndim,
+                                 size_t sizeof_dtype, int contig_flag,
+                                 int dtype_is_object);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *);
+
+/* TypeInfoCompare.proto */
+static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b);
+
+/* MemviewSliceValidateAndInit.proto */
+static int __Pyx_ValidateAndInit_memviewslice(
+                int *axes_specs,
+                int c_or_f_flag,
+                int buf_flags,
+                int ndim,
+                __Pyx_TypeInfo *dtype,
+                __Pyx_BufFmt_StackElem stack[],
+                __Pyx_memviewslice *memviewslice,
+                PyObject *original_obj);
+
+/* ObjectToMemviewSlice.proto */
+static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_double(PyObject *, int writable_flag);
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/
+static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/
+static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/
+static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/
+static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/
+static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/
+static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
+static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
+static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/
+static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'cpython.mem' */
+
+/* Module declarations from 'numpy' */
+
+/* Module declarations from 'numpy' */
+static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
+static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
+static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/
+
+/* Module declarations from 'cython.view' */
+
+/* Module declarations from 'cython' */
+
+/* Module declarations from 'libc.math' */
+
+/* Module declarations from 'prange_saliency_mbd' */
+static PyTypeObject *__pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____object___to_py = 0;
+static PyTypeObject *__pyx_array_type = 0;
+static PyTypeObject *__pyx_MemviewEnum_type = 0;
+static PyTypeObject *__pyx_memoryview_type = 0;
+static PyTypeObject *__pyx_memoryviewslice_type = 0;
+static PyObject *generic = 0;
+static PyObject *strided = 0;
+static PyObject *indirect = 0;
+static PyObject *contiguous = 0;
+static PyObject *indirect_contiguous = 0;
+static int __pyx_memoryview_thread_locks_used;
+static PyThread_type_lock __pyx_memoryview_thread_locks[8];
+static PyObject *__pyx_f_19prange_saliency_mbd_raster_scan(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int); /*proto*/
+static PyObject *__pyx_f_19prange_saliency_mbd_raster_scan_inv(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int); /*proto*/
+static PyObject *__pyx_f_19prange_saliency_mbd_mbd(PyArrayObject *, int, int); /*proto*/
+static PyObject *__pyx_f_19prange_saliency_mbd_f(PyObject *); /*proto*/
+static PyObject *__pyx_f_19prange_saliency_mbd_get_saliency_mbd(PyArrayObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_19prange_saliency_mbd_get_saliency_mbd *__pyx_optional_args); /*proto*/
+static PyObject *__Pyx_CFunc_object____object___to_py(PyObject *(*)(PyObject *)); /*proto*/
+static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/
+static void *__pyx_align_pointer(void *, size_t); /*proto*/
+static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/
+static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/
+static PyObject *_unellipsify(PyObject *, int); /*proto*/
+static PyObject *assert_direct_dimensions(Py_ssize_t *, int); /*proto*/
+static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/
+static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/
+static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/
+static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/
+static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/
+static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
+static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
+static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/
+static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/
+static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/
+static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/
+static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/
+static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/
+static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/
+static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/
+static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/
+static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/
+static int __pyx_memoryview_err_dim(PyObject *, char *, int); /*proto*/
+static int __pyx_memoryview_err(PyObject *, char *); /*proto*/
+static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/
+static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/
+static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/
+static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
+static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/
+static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/
+static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/
+static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/
+static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 };
+#define __Pyx_MODULE_NAME "prange_saliency_mbd"
+extern int __pyx_module_is_main_prange_saliency_mbd;
+int __pyx_module_is_main_prange_saliency_mbd = 0;
+
+/* Implementation of 'prange_saliency_mbd' */
+static PyObject *__pyx_builtin_xrange;
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_range;
+static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_ImportError;
+static PyObject *__pyx_builtin_MemoryError;
+static PyObject *__pyx_builtin_enumerate;
+static PyObject *__pyx_builtin_TypeError;
+static PyObject *__pyx_builtin_Ellipsis;
+static PyObject *__pyx_builtin_id;
+static PyObject *__pyx_builtin_IndexError;
+static const char __pyx_k_O[] = "O";
+static const char __pyx_k_T[] = "T";
+static const char __pyx_k_b[] = "b";
+static const char __pyx_k_c[] = "c";
+static const char __pyx_k_x[] = "x";
+static const char __pyx_k_VI[] = "VI";
+static const char __pyx_k_id[] = "id";
+static const char __pyx_k_np[] = "np";
+static const char __pyx_k_cov[] = "cov";
+static const char __pyx_k_img[] = "img";
+static const char __pyx_k_inv[] = "inv";
+static const char __pyx_k_max[] = "max";
+static const char __pyx_k_new[] = "__new__";
+static const char __pyx_k_obj[] = "obj";
+static const char __pyx_k_res[] = "res";
+static const char __pyx_k_sum[] = "sum";
+static const char __pyx_k_sys[] = "sys";
+static const char __pyx_k_axis[] = "axis";
+static const char __pyx_k_base[] = "base";
+static const char __pyx_k_dict[] = "__dict__";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_mean[] = "mean";
+static const char __pyx_k_mode[] = "mode";
+static const char __pyx_k_name[] = "name";
+static const char __pyx_k_ndim[] = "ndim";
+static const char __pyx_k_pack[] = "pack";
+static const char __pyx_k_size[] = "size";
+static const char __pyx_k_sqrt[] = "sqrt";
+static const char __pyx_k_step[] = "step";
+static const char __pyx_k_stop[] = "stop";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_wrap[] = "wrap";
+static const char __pyx_k_ASCII[] = "ASCII";
+static const char __pyx_k_cdist[] = "cdist";
+static const char __pyx_k_class[] = "__class__";
+static const char __pyx_k_color[] = "color";
+static const char __pyx_k_empty[] = "empty";
+static const char __pyx_k_error[] = "error";
+static const char __pyx_k_flags[] = "flags";
+static const char __pyx_k_numpy[] = "numpy";
+static const char __pyx_k_power[] = "power";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_scipy[] = "scipy";
+static const char __pyx_k_shape[] = "shape";
+static const char __pyx_k_start[] = "start";
+static const char __pyx_k_arange[] = "arange";
+static const char __pyx_k_encode[] = "encode";
+static const char __pyx_k_format[] = "format";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_linalg[] = "linalg";
+static const char __pyx_k_method[] = "method";
+static const char __pyx_k_name_2[] = "__name__";
+static const char __pyx_k_pickle[] = "pickle";
+static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_struct[] = "struct";
+static const char __pyx_k_unpack[] = "unpack";
+static const char __pyx_k_update[] = "update";
+static const char __pyx_k_xrange[] = "xrange";
+static const char __pyx_k_fortran[] = "fortran";
+static const char __pyx_k_maximum[] = "maximum";
+static const char __pyx_k_memview[] = "memview";
+static const char __pyx_k_reshape[] = "reshape";
+static const char __pyx_k_rgb2lab[] = "rgb2lab";
+static const char __pyx_k_skimage[] = "skimage";
+static const char __pyx_k_spatial[] = "spatial";
+static const char __pyx_k_Ellipsis[] = "Ellipsis";
+static const char __pyx_k_distance[] = "distance";
+static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_itemsize[] = "itemsize";
+static const char __pyx_k_meshgrid[] = "meshgrid";
+static const char __pyx_k_minimize[] = "minimize";
+static const char __pyx_k_pyx_type[] = "__pyx_type";
+static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_enumerate[] = "enumerate";
+static const char __pyx_k_full_like[] = "full_like";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
+static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_vectorize[] = "vectorize";
+static const char __pyx_k_IndexError[] = "IndexError";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_pyx_result[] = "__pyx_result";
+static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
+static const char __pyx_k_skimage_io[] = "skimage.io";
+static const char __pyx_k_ImportError[] = "ImportError";
+static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_PickleError[] = "PickleError";
+static const char __pyx_k_cfunc_to_py[] = "cfunc.to_py";
+static const char __pyx_k_mahalanobis[] = "mahalanobis";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_img_as_float[] = "img_as_float";
+static const char __pyx_k_pyx_checksum[] = "__pyx_checksum";
+static const char __pyx_k_skimage_util[] = "skimage.util";
+static const char __pyx_k_stringsource[] = "stringsource";
+static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer";
+static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_scipy_optimize[] = "scipy.optimize";
+static const char __pyx_k_View_MemoryView[] = "View.MemoryView";
+static const char __pyx_k_allocate_buffer[] = "allocate_buffer";
+static const char __pyx_k_dtype_is_object[] = "dtype_is_object";
+static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
+static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum";
+static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_strided_and_direct[] = "";
+static const char __pyx_k_strided_and_indirect[] = "";
+static const char __pyx_k_contiguous_and_direct[] = "";
+static const char __pyx_k_MemoryView_of_r_object[] = "";
+static const char __pyx_k_scipy_spatial_distance[] = "scipy.spatial.distance";
+static const char __pyx_k_MemoryView_of_r_at_0x_x[] = "";
+static const char __pyx_k_contiguous_and_indirect[] = "";
+static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'";
+static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d.";
+static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
+static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
+static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data.";
+static const char __pyx_k_Pyx_CFunc_object____object___t[] = "__Pyx_CFunc_object____object___to_py..wrap";
+static const char __pyx_k_strided_and_direct_or_indirect[] = "";
+static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
+static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
+static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides";
+static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory.";
+static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview";
+static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview";
+static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array";
+static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
+static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))";
+static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported";
+static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s";
+static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
+static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)";
+static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object";
+static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)";
+static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
+static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
+static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import";
+static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides.";
+static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
+static PyObject *__pyx_n_s_ASCII;
+static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri;
+static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is;
+static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor;
+static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi;
+static PyObject *__pyx_kp_s_Cannot_index_with_type_s;
+static PyObject *__pyx_n_s_Ellipsis;
+static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
+static PyObject *__pyx_n_s_ImportError;
+static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xb0;
+static PyObject *__pyx_n_s_IndexError;
+static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte;
+static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr;
+static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d;
+static PyObject *__pyx_n_s_MemoryError;
+static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x;
+static PyObject *__pyx_kp_s_MemoryView_of_r_object;
+static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
+static PyObject *__pyx_n_b_O;
+static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a;
+static PyObject *__pyx_n_s_PickleError;
+static PyObject *__pyx_n_s_Pyx_CFunc_object____object___t;
+static PyObject *__pyx_n_s_RuntimeError;
+static PyObject *__pyx_n_s_T;
+static PyObject *__pyx_n_s_TypeError;
+static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object;
+static PyObject *__pyx_n_s_VI;
+static PyObject *__pyx_n_s_ValueError;
+static PyObject *__pyx_n_s_View_MemoryView;
+static PyObject *__pyx_n_s_allocate_buffer;
+static PyObject *__pyx_n_s_arange;
+static PyObject *__pyx_n_s_axis;
+static PyObject *__pyx_n_s_b;
+static PyObject *__pyx_n_s_base;
+static PyObject *__pyx_n_s_c;
+static PyObject *__pyx_n_u_c;
+static PyObject *__pyx_n_s_cdist;
+static PyObject *__pyx_n_s_cfunc_to_py;
+static PyObject *__pyx_n_s_class;
+static PyObject *__pyx_n_s_cline_in_traceback;
+static PyObject *__pyx_n_s_color;
+static PyObject *__pyx_kp_s_contiguous_and_direct;
+static PyObject *__pyx_kp_s_contiguous_and_indirect;
+static PyObject *__pyx_n_s_cov;
+static PyObject *__pyx_n_s_dict;
+static PyObject *__pyx_n_s_distance;
+static PyObject *__pyx_n_s_dtype_is_object;
+static PyObject *__pyx_n_s_empty;
+static PyObject *__pyx_n_s_encode;
+static PyObject *__pyx_n_s_enumerate;
+static PyObject *__pyx_n_s_error;
+static PyObject *__pyx_n_s_flags;
+static PyObject *__pyx_n_s_format;
+static PyObject *__pyx_n_s_fortran;
+static PyObject *__pyx_n_u_fortran;
+static PyObject *__pyx_n_s_full_like;
+static PyObject *__pyx_n_s_getstate;
+static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi;
+static PyObject *__pyx_n_s_id;
+static PyObject *__pyx_n_s_img;
+static PyObject *__pyx_n_s_img_as_float;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_n_s_inv;
+static PyObject *__pyx_n_s_itemsize;
+static PyObject *__pyx_kp_s_itemsize_0_for_cython_array;
+static PyObject *__pyx_n_s_linalg;
+static PyObject *__pyx_n_s_mahalanobis;
+static PyObject *__pyx_n_s_main;
+static PyObject *__pyx_n_s_max;
+static PyObject *__pyx_n_s_maximum;
+static PyObject *__pyx_n_s_mean;
+static PyObject *__pyx_n_s_memview;
+static PyObject *__pyx_n_s_meshgrid;
+static PyObject *__pyx_n_s_method;
+static PyObject *__pyx_n_s_minimize;
+static PyObject *__pyx_n_s_mode;
+static PyObject *__pyx_n_s_name;
+static PyObject *__pyx_n_s_name_2;
+static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
+static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
+static PyObject *__pyx_n_s_ndim;
+static PyObject *__pyx_n_s_new;
+static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+static PyObject *__pyx_n_s_np;
+static PyObject *__pyx_n_s_numpy;
+static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to;
+static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor;
+static PyObject *__pyx_n_s_obj;
+static PyObject *__pyx_n_s_pack;
+static PyObject *__pyx_n_s_pickle;
+static PyObject *__pyx_n_s_power;
+static PyObject *__pyx_n_s_pyx_PickleError;
+static PyObject *__pyx_n_s_pyx_checksum;
+static PyObject *__pyx_n_s_pyx_getbuffer;
+static PyObject *__pyx_n_s_pyx_result;
+static PyObject *__pyx_n_s_pyx_state;
+static PyObject *__pyx_n_s_pyx_type;
+static PyObject *__pyx_n_s_pyx_unpickle_Enum;
+static PyObject *__pyx_n_s_pyx_vtable;
+static PyObject *__pyx_n_s_range;
+static PyObject *__pyx_n_s_reduce;
+static PyObject *__pyx_n_s_reduce_cython;
+static PyObject *__pyx_n_s_reduce_ex;
+static PyObject *__pyx_n_s_res;
+static PyObject *__pyx_n_s_reshape;
+static PyObject *__pyx_n_s_rgb2lab;
+static PyObject *__pyx_n_s_scipy;
+static PyObject *__pyx_n_s_scipy_optimize;
+static PyObject *__pyx_n_s_scipy_spatial_distance;
+static PyObject *__pyx_n_s_setstate;
+static PyObject *__pyx_n_s_setstate_cython;
+static PyObject *__pyx_n_s_shape;
+static PyObject *__pyx_n_s_size;
+static PyObject *__pyx_n_s_skimage;
+static PyObject *__pyx_n_s_skimage_io;
+static PyObject *__pyx_n_s_skimage_util;
+static PyObject *__pyx_n_s_spatial;
+static PyObject *__pyx_n_s_sqrt;
+static PyObject *__pyx_n_s_start;
+static PyObject *__pyx_n_s_step;
+static PyObject *__pyx_n_s_stop;
+static PyObject *__pyx_kp_s_strided_and_direct;
+static PyObject *__pyx_kp_s_strided_and_direct_or_indirect;
+static PyObject *__pyx_kp_s_strided_and_indirect;
+static PyObject *__pyx_kp_s_stringsource;
+static PyObject *__pyx_n_s_struct;
+static PyObject *__pyx_n_s_sum;
+static PyObject *__pyx_n_s_sys;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_kp_s_unable_to_allocate_array_data;
+static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str;
+static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
+static PyObject *__pyx_n_s_unpack;
+static PyObject *__pyx_n_s_update;
+static PyObject *__pyx_n_s_vectorize;
+static PyObject *__pyx_n_s_wrap;
+static PyObject *__pyx_n_s_x;
+static PyObject *__pyx_n_s_xrange;
+static PyObject *__pyx_pf_19prange_saliency_mbd_get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method, PyObject *__pyx_v_res); /* proto */
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
+static PyObject *__pyx_pf_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap(PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */
+static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */
+static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */
+static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */
+static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */
+static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
+static PyObject *__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____object___to_py(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_float_0_5;
+static PyObject *__pyx_float_255_0;
+static PyObject *__pyx_int_0;
+static PyObject *__pyx_int_1;
+static PyObject *__pyx_int_2;
+static PyObject *__pyx_int_3;
+static PyObject *__pyx_int_4;
+static PyObject *__pyx_int_10000000;
+static PyObject *__pyx_int_184977713;
+static PyObject *__pyx_int_neg_1;
+static PyObject *__pyx_slice_;
+static PyObject *__pyx_tuple__2;
+static PyObject *__pyx_tuple__3;
+static PyObject *__pyx_tuple__4;
+static PyObject *__pyx_tuple__5;
+static PyObject *__pyx_tuple__6;
+static PyObject *__pyx_tuple__7;
+static PyObject *__pyx_tuple__8;
+static PyObject *__pyx_tuple__9;
+static PyObject *__pyx_tuple__10;
+static PyObject *__pyx_tuple__11;
+static PyObject *__pyx_tuple__12;
+static PyObject *__pyx_tuple__13;
+static PyObject *__pyx_tuple__14;
+static PyObject *__pyx_tuple__15;
+static PyObject *__pyx_tuple__16;
+static PyObject *__pyx_tuple__17;
+static PyObject *__pyx_tuple__19;
+static PyObject *__pyx_tuple__20;
+static PyObject *__pyx_tuple__21;
+static PyObject *__pyx_tuple__22;
+static PyObject *__pyx_tuple__23;
+static PyObject *__pyx_tuple__24;
+static PyObject *__pyx_tuple__25;
+static PyObject *__pyx_tuple__26;
+static PyObject *__pyx_tuple__27;
+static PyObject *__pyx_tuple__28;
+static PyObject *__pyx_tuple__29;
+static PyObject *__pyx_tuple__30;
+static PyObject *__pyx_tuple__31;
+static PyObject *__pyx_tuple__32;
+static PyObject *__pyx_tuple__33;
+static PyObject *__pyx_tuple__34;
+static PyObject *__pyx_tuple__35;
+static PyObject *__pyx_tuple__36;
+static PyObject *__pyx_tuple__37;
+static PyObject *__pyx_tuple__38;
+static PyObject *__pyx_tuple__39;
+static PyObject *__pyx_tuple__40;
+static PyObject *__pyx_tuple__41;
+static PyObject *__pyx_codeobj__18;
+static PyObject *__pyx_codeobj__42;
+/* Late includes */
+
+/* "prange_saliency_mbd.pyx":17
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cdef raster_scan(double [:,:] img, double [:,:] L, double [:,:] U, double [:,:] D, int res):             # <<<<<<<<<<<<<<
+ * 	# cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double)
+ * 	cdef int n_rows = img.shape[0]
+ */
+
+static PyObject *__pyx_f_19prange_saliency_mbd_raster_scan(__Pyx_memviewslice __pyx_v_img, __Pyx_memviewslice __pyx_v_L, __Pyx_memviewslice __pyx_v_U, __Pyx_memviewslice __pyx_v_D, int __pyx_v_res) {
+  int __pyx_v_n_rows;
+  int __pyx_v_n_cols;
+  Py_ssize_t __pyx_v_x;
+  Py_ssize_t __pyx_v_y;
+  double __pyx_v_ix;
+  double __pyx_v_d;
+  double __pyx_v_u1;
+  double __pyx_v_l1;
+  double __pyx_v_u2;
+  double __pyx_v_l2;
+  double __pyx_v_b1;
+  double __pyx_v_b2;
+  int __pyx_v_r2;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
+  Py_ssize_t __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *(*__pyx_t_8)(PyObject *);
+  Py_ssize_t __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  double __pyx_t_12;
+  double __pyx_t_13;
+  double __pyx_t_14;
+  double __pyx_t_15;
+  int __pyx_t_16;
+  int __pyx_t_17;
+  __Pyx_memviewslice __pyx_t_18 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_t_19;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("raster_scan", 0);
+
+  /* "prange_saliency_mbd.pyx":19
+ * cdef raster_scan(double [:,:] img, double [:,:] L, double [:,:] U, double [:,:] D, int res):
+ * 	# cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double)
+ * 	cdef int n_rows = img.shape[0]             # <<<<<<<<<<<<<<
+ * 	cdef int n_cols = img.shape[1]
+ * 
+ */
+  __pyx_v_n_rows = (__pyx_v_img.shape[0]);
+
+  /* "prange_saliency_mbd.pyx":20
+ * 	# cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double)
+ * 	cdef int n_rows = img.shape[0]
+ * 	cdef int n_cols = img.shape[1]             # <<<<<<<<<<<<<<
+ * 
+ * 	cdef Py_ssize_t x, y
+ */
+  __pyx_v_n_cols = (__pyx_v_img.shape[1]);
+
+  /* "prange_saliency_mbd.pyx":31
+ * 	cdef double b1
+ * 	cdef double b2
+ * 	cdef int r2 = res//2             # <<<<<<<<<<<<<<
+ * 	for x in xrange(1,n_rows - res - 1, res):
+ * 		for y in xrange(1,n_cols - res - 1, res):
+ */
+  __pyx_v_r2 = __Pyx_div_long(__pyx_v_res, 2);
+
+  /* "prange_saliency_mbd.pyx":32
+ * 	cdef double b2
+ * 	cdef int r2 = res//2
+ * 	for x in xrange(1,n_rows - res - 1, res):             # <<<<<<<<<<<<<<
+ * 		for y in xrange(1,n_cols - res - 1, res):
+ * 			# ix = np.min(img[x:x+res,y:y+res])
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_long(((__pyx_v_n_rows - __pyx_v_res) - 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_res); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_xrange, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+    __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+  } else {
+    __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 32, __pyx_L1_error)
+        #else
+        __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        #endif
+      } else {
+        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 32, __pyx_L1_error)
+        #else
+        __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        #endif
+      }
+    } else {
+      __pyx_t_2 = __pyx_t_5(__pyx_t_3);
+      if (unlikely(!__pyx_t_2)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 32, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 32, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_x = __pyx_t_6;
+
+    /* "prange_saliency_mbd.pyx":33
+ * 	cdef int r2 = res//2
+ * 	for x in xrange(1,n_rows - res - 1, res):
+ * 		for y in xrange(1,n_cols - res - 1, res):             # <<<<<<<<<<<<<<
+ * 			# ix = np.min(img[x:x+res,y:y+res])
+ * 			# d = np.mean(D[x:x+res,y:y+res])
+ */
+    __pyx_t_2 = __Pyx_PyInt_From_long(((__pyx_v_n_cols - __pyx_v_res) - 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_res); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_INCREF(__pyx_int_1);
+    __Pyx_GIVEREF(__pyx_int_1);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_int_1);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_1);
+    __pyx_t_2 = 0;
+    __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_xrange, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+      __pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7); __pyx_t_6 = 0;
+      __pyx_t_8 = NULL;
+    } else {
+      __pyx_t_6 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 33, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_8)) {
+        if (likely(PyList_CheckExact(__pyx_t_7))) {
+          if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_7)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_1 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 33, __pyx_L1_error)
+          #else
+          __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          #endif
+        } else {
+          if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 33, __pyx_L1_error)
+          #else
+          __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          #endif
+        }
+      } else {
+        __pyx_t_1 = __pyx_t_8(__pyx_t_7);
+        if (unlikely(!__pyx_t_1)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+            else __PYX_ERR(0, 33, __pyx_L1_error)
+          }
+          break;
+        }
+        __Pyx_GOTREF(__pyx_t_1);
+      }
+      __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 33, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_y = __pyx_t_9;
+
+      /* "prange_saliency_mbd.pyx":36
+ * 			# ix = np.min(img[x:x+res,y:y+res])
+ * 			# d = np.mean(D[x:x+res,y:y+res])
+ * 			ix = img[x+r2,y+r2]             # <<<<<<<<<<<<<<
+ * 			d = D[x +r2,y+r2]
+ * 
+ */
+      __pyx_t_10 = (__pyx_v_x + __pyx_v_r2);
+      __pyx_t_11 = (__pyx_v_y + __pyx_v_r2);
+      __pyx_v_ix = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_img.data + __pyx_t_10 * __pyx_v_img.strides[0]) ) + __pyx_t_11 * __pyx_v_img.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":37
+ * 			# d = np.mean(D[x:x+res,y:y+res])
+ * 			ix = img[x+r2,y+r2]
+ * 			d = D[x +r2,y+r2]             # <<<<<<<<<<<<<<
+ * 
+ * 			# u1 = np.max(U[x-1:x-1+res,y])
+ */
+      __pyx_t_11 = (__pyx_v_x + __pyx_v_r2);
+      __pyx_t_10 = (__pyx_v_y + __pyx_v_r2);
+      __pyx_v_d = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_D.data + __pyx_t_11 * __pyx_v_D.strides[0]) ) + __pyx_t_10 * __pyx_v_D.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":41
+ * 			# u1 = np.max(U[x-1:x-1+res,y])
+ * 			# l1 = np.min(L[x-1:x-1+res,y])
+ * 			u1 = U[x-1+r2,y+r2]             # <<<<<<<<<<<<<<
+ * 			l1 = L[x-1+r2,y+r2]
+ * 
+ */
+      __pyx_t_10 = ((__pyx_v_x - 1) + __pyx_v_r2);
+      __pyx_t_11 = (__pyx_v_y + __pyx_v_r2);
+      __pyx_v_u1 = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_U.data + __pyx_t_10 * __pyx_v_U.strides[0]) ) + __pyx_t_11 * __pyx_v_U.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":42
+ * 			# l1 = np.min(L[x-1:x-1+res,y])
+ * 			u1 = U[x-1+r2,y+r2]
+ * 			l1 = L[x-1+r2,y+r2]             # <<<<<<<<<<<<<<
+ * 
+ * 			# u2 = np.max(U[x:x+res,y-1:y-1+res])
+ */
+      __pyx_t_11 = ((__pyx_v_x - 1) + __pyx_v_r2);
+      __pyx_t_10 = (__pyx_v_y + __pyx_v_r2);
+      __pyx_v_l1 = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_L.data + __pyx_t_11 * __pyx_v_L.strides[0]) ) + __pyx_t_10 * __pyx_v_L.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":46
+ * 			# u2 = np.max(U[x:x+res,y-1:y-1+res])
+ * 			# l2 = np.min(L[x:x+res,y-1:y-1+res])
+ * 			u2 = U[x+r2,y-1+r2]             # <<<<<<<<<<<<<<
+ * 			l2 = L[x+r2,y-1+r2]
+ * 
+ */
+      __pyx_t_10 = (__pyx_v_x + __pyx_v_r2);
+      __pyx_t_11 = ((__pyx_v_y - 1) + __pyx_v_r2);
+      __pyx_v_u2 = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_U.data + __pyx_t_10 * __pyx_v_U.strides[0]) ) + __pyx_t_11 * __pyx_v_U.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":47
+ * 			# l2 = np.min(L[x:x+res,y-1:y-1+res])
+ * 			u2 = U[x+r2,y-1+r2]
+ * 			l2 = L[x+r2,y-1+r2]             # <<<<<<<<<<<<<<
+ * 
+ * 			b1 = max(u1,ix) - min(l1,ix)
+ */
+      __pyx_t_11 = (__pyx_v_x + __pyx_v_r2);
+      __pyx_t_10 = ((__pyx_v_y - 1) + __pyx_v_r2);
+      __pyx_v_l2 = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_L.data + __pyx_t_11 * __pyx_v_L.strides[0]) ) + __pyx_t_10 * __pyx_v_L.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":49
+ * 			l2 = L[x+r2,y-1+r2]
+ * 
+ * 			b1 = max(u1,ix) - min(l1,ix)             # <<<<<<<<<<<<<<
+ * 			b2 = max(u2,ix) - min(l2,ix)
+ * 
+ */
+      __pyx_t_12 = __pyx_v_ix;
+      __pyx_t_13 = __pyx_v_u1;
+      if (((__pyx_t_12 > __pyx_t_13) != 0)) {
+        __pyx_t_14 = __pyx_t_12;
+      } else {
+        __pyx_t_14 = __pyx_t_13;
+      }
+      __pyx_t_12 = __pyx_v_ix;
+      __pyx_t_13 = __pyx_v_l1;
+      if (((__pyx_t_12 < __pyx_t_13) != 0)) {
+        __pyx_t_15 = __pyx_t_12;
+      } else {
+        __pyx_t_15 = __pyx_t_13;
+      }
+      __pyx_v_b1 = (__pyx_t_14 - __pyx_t_15);
+
+      /* "prange_saliency_mbd.pyx":50
+ * 
+ * 			b1 = max(u1,ix) - min(l1,ix)
+ * 			b2 = max(u2,ix) - min(l2,ix)             # <<<<<<<<<<<<<<
+ * 
+ * 			if d <= b1 and d <= b2:
+ */
+      __pyx_t_15 = __pyx_v_ix;
+      __pyx_t_14 = __pyx_v_u2;
+      if (((__pyx_t_15 > __pyx_t_14) != 0)) {
+        __pyx_t_12 = __pyx_t_15;
+      } else {
+        __pyx_t_12 = __pyx_t_14;
+      }
+      __pyx_t_15 = __pyx_v_ix;
+      __pyx_t_14 = __pyx_v_l2;
+      if (((__pyx_t_15 < __pyx_t_14) != 0)) {
+        __pyx_t_13 = __pyx_t_15;
+      } else {
+        __pyx_t_13 = __pyx_t_14;
+      }
+      __pyx_v_b2 = (__pyx_t_12 - __pyx_t_13);
+
+      /* "prange_saliency_mbd.pyx":52
+ * 			b2 = max(u2,ix) - min(l2,ix)
+ * 
+ * 			if d <= b1 and d <= b2:             # <<<<<<<<<<<<<<
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:
+ */
+      __pyx_t_17 = ((__pyx_v_d <= __pyx_v_b1) != 0);
+      if (__pyx_t_17) {
+      } else {
+        __pyx_t_16 = __pyx_t_17;
+        goto __pyx_L8_bool_binop_done;
+      }
+      __pyx_t_17 = ((__pyx_v_d <= __pyx_v_b2) != 0);
+      __pyx_t_16 = __pyx_t_17;
+      __pyx_L8_bool_binop_done:;
+      if (__pyx_t_16) {
+
+        /* "prange_saliency_mbd.pyx":53
+ * 
+ * 			if d <= b1 and d <= b2:
+ * 				continue             # <<<<<<<<<<<<<<
+ * 			elif b1 < d and b1 <= b2:
+ * 				D[x:x+res,y:y+res] = b1
+ */
+        goto __pyx_L5_continue;
+
+        /* "prange_saliency_mbd.pyx":52
+ * 			b2 = max(u2,ix) - min(l2,ix)
+ * 
+ * 			if d <= b1 and d <= b2:             # <<<<<<<<<<<<<<
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:
+ */
+      }
+
+      /* "prange_saliency_mbd.pyx":54
+ * 			if d <= b1 and d <= b2:
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:             # <<<<<<<<<<<<<<
+ * 				D[x:x+res,y:y+res] = b1
+ * 				U[x:x+res,y:y+res] = max(u1,ix)
+ */
+      __pyx_t_17 = ((__pyx_v_b1 < __pyx_v_d) != 0);
+      if (__pyx_t_17) {
+      } else {
+        __pyx_t_16 = __pyx_t_17;
+        goto __pyx_L10_bool_binop_done;
+      }
+      __pyx_t_17 = ((__pyx_v_b1 <= __pyx_v_b2) != 0);
+      __pyx_t_16 = __pyx_t_17;
+      __pyx_L10_bool_binop_done:;
+      if (__pyx_t_16) {
+
+        /* "prange_saliency_mbd.pyx":55
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:
+ * 				D[x:x+res,y:y+res] = b1             # <<<<<<<<<<<<<<
+ * 				U[x:x+res,y:y+res] = max(u1,ix)
+ * 				L[x:x+res,y:y+res] = min(l1,ix)
+ */
+        __pyx_t_18.data = __pyx_v_D.data;
+        __pyx_t_18.memview = __pyx_v_D.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_D.shape[0], __pyx_v_D.strides[0], __pyx_v_D.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 55, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_D.shape[1], __pyx_v_D.strides[1], __pyx_v_D.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 55, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_v_b1;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":56
+ * 			elif b1 < d and b1 <= b2:
+ * 				D[x:x+res,y:y+res] = b1
+ * 				U[x:x+res,y:y+res] = max(u1,ix)             # <<<<<<<<<<<<<<
+ * 				L[x:x+res,y:y+res] = min(l1,ix)
+ * 			else:
+ */
+        __pyx_t_13 = __pyx_v_ix;
+        __pyx_t_12 = __pyx_v_u1;
+        if (((__pyx_t_13 > __pyx_t_12) != 0)) {
+          __pyx_t_15 = __pyx_t_13;
+        } else {
+          __pyx_t_15 = __pyx_t_12;
+        }
+        __pyx_t_18.data = __pyx_v_U.data;
+        __pyx_t_18.memview = __pyx_v_U.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_U.shape[0], __pyx_v_U.strides[0], __pyx_v_U.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 56, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_U.shape[1], __pyx_v_U.strides[1], __pyx_v_U.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 56, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_t_15;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":57
+ * 				D[x:x+res,y:y+res] = b1
+ * 				U[x:x+res,y:y+res] = max(u1,ix)
+ * 				L[x:x+res,y:y+res] = min(l1,ix)             # <<<<<<<<<<<<<<
+ * 			else:
+ * 				D[x:x+res,y:y+res] = b2
+ */
+        __pyx_t_15 = __pyx_v_ix;
+        __pyx_t_13 = __pyx_v_l1;
+        if (((__pyx_t_15 < __pyx_t_13) != 0)) {
+          __pyx_t_12 = __pyx_t_15;
+        } else {
+          __pyx_t_12 = __pyx_t_13;
+        }
+        __pyx_t_18.data = __pyx_v_L.data;
+        __pyx_t_18.memview = __pyx_v_L.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_L.shape[0], __pyx_v_L.strides[0], __pyx_v_L.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 57, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_L.shape[1], __pyx_v_L.strides[1], __pyx_v_L.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 57, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_t_12;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":54
+ * 			if d <= b1 and d <= b2:
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:             # <<<<<<<<<<<<<<
+ * 				D[x:x+res,y:y+res] = b1
+ * 				U[x:x+res,y:y+res] = max(u1,ix)
+ */
+        goto __pyx_L7;
+      }
+
+      /* "prange_saliency_mbd.pyx":59
+ * 				L[x:x+res,y:y+res] = min(l1,ix)
+ * 			else:
+ * 				D[x:x+res,y:y+res] = b2             # <<<<<<<<<<<<<<
+ * 				U[x:x+res,y:y+res] = max(u2,ix)
+ * 				L[x:x+res,y:y+res] = min(l2,ix)
+ */
+      /*else*/ {
+        __pyx_t_18.data = __pyx_v_D.data;
+        __pyx_t_18.memview = __pyx_v_D.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_D.shape[0], __pyx_v_D.strides[0], __pyx_v_D.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 59, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_D.shape[1], __pyx_v_D.strides[1], __pyx_v_D.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 59, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_v_b2;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":60
+ * 			else:
+ * 				D[x:x+res,y:y+res] = b2
+ * 				U[x:x+res,y:y+res] = max(u2,ix)             # <<<<<<<<<<<<<<
+ * 				L[x:x+res,y:y+res] = min(l2,ix)
+ * 
+ */
+        __pyx_t_12 = __pyx_v_ix;
+        __pyx_t_15 = __pyx_v_u2;
+        if (((__pyx_t_12 > __pyx_t_15) != 0)) {
+          __pyx_t_13 = __pyx_t_12;
+        } else {
+          __pyx_t_13 = __pyx_t_15;
+        }
+        __pyx_t_18.data = __pyx_v_U.data;
+        __pyx_t_18.memview = __pyx_v_U.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_U.shape[0], __pyx_v_U.strides[0], __pyx_v_U.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 60, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_U.shape[1], __pyx_v_U.strides[1], __pyx_v_U.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 60, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_t_13;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":61
+ * 				D[x:x+res,y:y+res] = b2
+ * 				U[x:x+res,y:y+res] = max(u2,ix)
+ * 				L[x:x+res,y:y+res] = min(l2,ix)             # <<<<<<<<<<<<<<
+ * 
+ * 	return True
+ */
+        __pyx_t_13 = __pyx_v_ix;
+        __pyx_t_12 = __pyx_v_l2;
+        if (((__pyx_t_13 < __pyx_t_12) != 0)) {
+          __pyx_t_15 = __pyx_t_13;
+        } else {
+          __pyx_t_15 = __pyx_t_12;
+        }
+        __pyx_t_18.data = __pyx_v_L.data;
+        __pyx_t_18.memview = __pyx_v_L.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_L.shape[0], __pyx_v_L.strides[0], __pyx_v_L.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 61, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_L.shape[1], __pyx_v_L.strides[1], __pyx_v_L.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 61, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_t_15;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+      }
+      __pyx_L7:;
+
+      /* "prange_saliency_mbd.pyx":33
+ * 	cdef int r2 = res//2
+ * 	for x in xrange(1,n_rows - res - 1, res):
+ * 		for y in xrange(1,n_cols - res - 1, res):             # <<<<<<<<<<<<<<
+ * 			# ix = np.min(img[x:x+res,y:y+res])
+ * 			# d = np.mean(D[x:x+res,y:y+res])
+ */
+      __pyx_L5_continue:;
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "prange_saliency_mbd.pyx":32
+ * 	cdef double b2
+ * 	cdef int r2 = res//2
+ * 	for x in xrange(1,n_rows - res - 1, res):             # <<<<<<<<<<<<<<
+ * 		for y in xrange(1,n_cols - res - 1, res):
+ * 			# ix = np.min(img[x:x+res,y:y+res])
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "prange_saliency_mbd.pyx":63
+ * 				L[x:x+res,y:y+res] = min(l2,ix)
+ * 
+ * 	return True             # <<<<<<<<<<<<<<
+ * 
+ * @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_True);
+  __pyx_r = Py_True;
+  goto __pyx_L0;
+
+  /* "prange_saliency_mbd.pyx":17
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cdef raster_scan(double [:,:] img, double [:,:] L, double [:,:] U, double [:,:] D, int res):             # <<<<<<<<<<<<<<
+ * 	# cdef np.ndarray[double, ndim=2] img = np.ascontiguousarray(img1, dtype = double)
+ * 	cdef int n_rows = img.shape[0]
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_7);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+  __Pyx_AddTraceback("prange_saliency_mbd.raster_scan", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "prange_saliency_mbd.pyx":67
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cdef raster_scan_inv(double [:,:] img, double [:,:] L, double [:,:] U, double [:,:] D, int res):             # <<<<<<<<<<<<<<
+ * 	cdef int n_rows
+ * 	cdef int n_cols
+ */
+
+static PyObject *__pyx_f_19prange_saliency_mbd_raster_scan_inv(__Pyx_memviewslice __pyx_v_img, __Pyx_memviewslice __pyx_v_L, __Pyx_memviewslice __pyx_v_U, __Pyx_memviewslice __pyx_v_D, int __pyx_v_res) {
+  int __pyx_v_n_rows;
+  int __pyx_v_n_cols;
+  Py_ssize_t __pyx_v_x;
+  Py_ssize_t __pyx_v_y;
+  double __pyx_v_ix;
+  double __pyx_v_d;
+  double __pyx_v_u1;
+  double __pyx_v_l1;
+  double __pyx_v_u2;
+  double __pyx_v_l2;
+  double __pyx_v_b1;
+  double __pyx_v_b2;
+  int __pyx_v_r2;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
+  Py_ssize_t __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *(*__pyx_t_8)(PyObject *);
+  Py_ssize_t __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  double __pyx_t_12;
+  double __pyx_t_13;
+  double __pyx_t_14;
+  double __pyx_t_15;
+  int __pyx_t_16;
+  int __pyx_t_17;
+  __Pyx_memviewslice __pyx_t_18 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_t_19;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("raster_scan_inv", 0);
+
+  /* "prange_saliency_mbd.pyx":71
+ * 	cdef int n_cols
+ * 
+ * 	n_rows = img.shape[0]             # <<<<<<<<<<<<<<
+ * 	n_cols = img.shape[1]
+ * 
+ */
+  __pyx_v_n_rows = (__pyx_v_img.shape[0]);
+
+  /* "prange_saliency_mbd.pyx":72
+ * 
+ * 	n_rows = img.shape[0]
+ * 	n_cols = img.shape[1]             # <<<<<<<<<<<<<<
+ * 
+ * 	cdef Py_ssize_t x, y
+ */
+  __pyx_v_n_cols = (__pyx_v_img.shape[1]);
+
+  /* "prange_saliency_mbd.pyx":83
+ * 	cdef double b1
+ * 	cdef double b2
+ * 	cdef int r2 = res//2             # <<<<<<<<<<<<<<
+ * 	for x in xrange(n_rows - 2 - res,1,-1*res):
+ * 		for y in xrange(n_cols - 2 - res,1,-1*res):
+ */
+  __pyx_v_r2 = __Pyx_div_long(__pyx_v_res, 2);
+
+  /* "prange_saliency_mbd.pyx":84
+ * 	cdef double b2
+ * 	cdef int r2 = res//2
+ * 	for x in xrange(n_rows - 2 - res,1,-1*res):             # <<<<<<<<<<<<<<
+ * 		for y in xrange(n_cols - 2 - res,1,-1*res):
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_long(((__pyx_v_n_rows - 2) - __pyx_v_res)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_From_long((-1L * __pyx_v_res)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_xrange, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+    __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+  } else {
+    __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 84, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 84, __pyx_L1_error)
+        #else
+        __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        #endif
+      } else {
+        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 84, __pyx_L1_error)
+        #else
+        __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        #endif
+      }
+    } else {
+      __pyx_t_2 = __pyx_t_5(__pyx_t_3);
+      if (unlikely(!__pyx_t_2)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 84, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_x = __pyx_t_6;
+
+    /* "prange_saliency_mbd.pyx":85
+ * 	cdef int r2 = res//2
+ * 	for x in xrange(n_rows - 2 - res,1,-1*res):
+ * 		for y in xrange(n_cols - 2 - res,1,-1*res):             # <<<<<<<<<<<<<<
+ * 
+ * 			# ix = np.min(img[x:x+res,y:y+res])
+ */
+    __pyx_t_2 = __Pyx_PyInt_From_long(((__pyx_v_n_cols - 2) - __pyx_v_res)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = __Pyx_PyInt_From_long((-1L * __pyx_v_res)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2);
+    __Pyx_INCREF(__pyx_int_1);
+    __Pyx_GIVEREF(__pyx_int_1);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_int_1);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_1);
+    __pyx_t_2 = 0;
+    __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_xrange, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+      __pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7); __pyx_t_6 = 0;
+      __pyx_t_8 = NULL;
+    } else {
+      __pyx_t_6 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 85, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_8)) {
+        if (likely(PyList_CheckExact(__pyx_t_7))) {
+          if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_7)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_1 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 85, __pyx_L1_error)
+          #else
+          __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          #endif
+        } else {
+          if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 85, __pyx_L1_error)
+          #else
+          __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
+          #endif
+        }
+      } else {
+        __pyx_t_1 = __pyx_t_8(__pyx_t_7);
+        if (unlikely(!__pyx_t_1)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+            else __PYX_ERR(0, 85, __pyx_L1_error)
+          }
+          break;
+        }
+        __Pyx_GOTREF(__pyx_t_1);
+      }
+      __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_v_y = __pyx_t_9;
+
+      /* "prange_saliency_mbd.pyx":89
+ * 			# ix = np.min(img[x:x+res,y:y+res])
+ * 			# d = np.mean(D[x:x+res,y:y+res])
+ * 			ix = img[x+r2,y+r2]             # <<<<<<<<<<<<<<
+ * 			d = D[x +r2,y+r2]
+ * 
+ */
+      __pyx_t_10 = (__pyx_v_x + __pyx_v_r2);
+      __pyx_t_11 = (__pyx_v_y + __pyx_v_r2);
+      __pyx_v_ix = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_img.data + __pyx_t_10 * __pyx_v_img.strides[0]) ) + __pyx_t_11 * __pyx_v_img.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":90
+ * 			# d = np.mean(D[x:x+res,y:y+res])
+ * 			ix = img[x+r2,y+r2]
+ * 			d = D[x +r2,y+r2]             # <<<<<<<<<<<<<<
+ * 
+ * 			# u1 = np.max(U[x+1:x+1+res,y:y+res])
+ */
+      __pyx_t_11 = (__pyx_v_x + __pyx_v_r2);
+      __pyx_t_10 = (__pyx_v_y + __pyx_v_r2);
+      __pyx_v_d = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_D.data + __pyx_t_11 * __pyx_v_D.strides[0]) ) + __pyx_t_10 * __pyx_v_D.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":94
+ * 			# u1 = np.max(U[x+1:x+1+res,y:y+res])
+ * 			# l1 = np.min(L[x+1:x+1+res,y:y+res])
+ * 			u1 = U[x+1+r2,y+r2]             # <<<<<<<<<<<<<<
+ * 			l1 = L[x+1+r2,y+r2]
+ * 
+ */
+      __pyx_t_10 = ((__pyx_v_x + 1) + __pyx_v_r2);
+      __pyx_t_11 = (__pyx_v_y + __pyx_v_r2);
+      __pyx_v_u1 = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_U.data + __pyx_t_10 * __pyx_v_U.strides[0]) ) + __pyx_t_11 * __pyx_v_U.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":95
+ * 			# l1 = np.min(L[x+1:x+1+res,y:y+res])
+ * 			u1 = U[x+1+r2,y+r2]
+ * 			l1 = L[x+1+r2,y+r2]             # <<<<<<<<<<<<<<
+ * 
+ * 			# u2 = np.max(U[x:x+res,y+1:y+1+res])
+ */
+      __pyx_t_11 = ((__pyx_v_x + 1) + __pyx_v_r2);
+      __pyx_t_10 = (__pyx_v_y + __pyx_v_r2);
+      __pyx_v_l1 = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_L.data + __pyx_t_11 * __pyx_v_L.strides[0]) ) + __pyx_t_10 * __pyx_v_L.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":99
+ * 			# u2 = np.max(U[x:x+res,y+1:y+1+res])
+ * 			# l2 = np.min(L[x:x+res,y+1:y+1+res])
+ * 			u2 = U[x+r2,y+1+r2]             # <<<<<<<<<<<<<<
+ * 			l2 = L[x+r2,y+1+r2]
+ * 
+ */
+      __pyx_t_10 = (__pyx_v_x + __pyx_v_r2);
+      __pyx_t_11 = ((__pyx_v_y + 1) + __pyx_v_r2);
+      __pyx_v_u2 = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_U.data + __pyx_t_10 * __pyx_v_U.strides[0]) ) + __pyx_t_11 * __pyx_v_U.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":100
+ * 			# l2 = np.min(L[x:x+res,y+1:y+1+res])
+ * 			u2 = U[x+r2,y+1+r2]
+ * 			l2 = L[x+r2,y+1+r2]             # <<<<<<<<<<<<<<
+ * 
+ * 			b1 = max(u1,ix) - min(l1,ix)
+ */
+      __pyx_t_11 = (__pyx_v_x + __pyx_v_r2);
+      __pyx_t_10 = ((__pyx_v_y + 1) + __pyx_v_r2);
+      __pyx_v_l2 = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_L.data + __pyx_t_11 * __pyx_v_L.strides[0]) ) + __pyx_t_10 * __pyx_v_L.strides[1]) )));
+
+      /* "prange_saliency_mbd.pyx":102
+ * 			l2 = L[x+r2,y+1+r2]
+ * 
+ * 			b1 = max(u1,ix) - min(l1,ix)             # <<<<<<<<<<<<<<
+ * 			b2 = max(u2,ix) - min(l2,ix)
+ * 
+ */
+      __pyx_t_12 = __pyx_v_ix;
+      __pyx_t_13 = __pyx_v_u1;
+      if (((__pyx_t_12 > __pyx_t_13) != 0)) {
+        __pyx_t_14 = __pyx_t_12;
+      } else {
+        __pyx_t_14 = __pyx_t_13;
+      }
+      __pyx_t_12 = __pyx_v_ix;
+      __pyx_t_13 = __pyx_v_l1;
+      if (((__pyx_t_12 < __pyx_t_13) != 0)) {
+        __pyx_t_15 = __pyx_t_12;
+      } else {
+        __pyx_t_15 = __pyx_t_13;
+      }
+      __pyx_v_b1 = (__pyx_t_14 - __pyx_t_15);
+
+      /* "prange_saliency_mbd.pyx":103
+ * 
+ * 			b1 = max(u1,ix) - min(l1,ix)
+ * 			b2 = max(u2,ix) - min(l2,ix)             # <<<<<<<<<<<<<<
+ * 
+ * 			if d <= b1 and d <= b2:
+ */
+      __pyx_t_15 = __pyx_v_ix;
+      __pyx_t_14 = __pyx_v_u2;
+      if (((__pyx_t_15 > __pyx_t_14) != 0)) {
+        __pyx_t_12 = __pyx_t_15;
+      } else {
+        __pyx_t_12 = __pyx_t_14;
+      }
+      __pyx_t_15 = __pyx_v_ix;
+      __pyx_t_14 = __pyx_v_l2;
+      if (((__pyx_t_15 < __pyx_t_14) != 0)) {
+        __pyx_t_13 = __pyx_t_15;
+      } else {
+        __pyx_t_13 = __pyx_t_14;
+      }
+      __pyx_v_b2 = (__pyx_t_12 - __pyx_t_13);
+
+      /* "prange_saliency_mbd.pyx":105
+ * 			b2 = max(u2,ix) - min(l2,ix)
+ * 
+ * 			if d <= b1 and d <= b2:             # <<<<<<<<<<<<<<
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:
+ */
+      __pyx_t_17 = ((__pyx_v_d <= __pyx_v_b1) != 0);
+      if (__pyx_t_17) {
+      } else {
+        __pyx_t_16 = __pyx_t_17;
+        goto __pyx_L8_bool_binop_done;
+      }
+      __pyx_t_17 = ((__pyx_v_d <= __pyx_v_b2) != 0);
+      __pyx_t_16 = __pyx_t_17;
+      __pyx_L8_bool_binop_done:;
+      if (__pyx_t_16) {
+
+        /* "prange_saliency_mbd.pyx":106
+ * 
+ * 			if d <= b1 and d <= b2:
+ * 				continue             # <<<<<<<<<<<<<<
+ * 			elif b1 < d and b1 <= b2:
+ * 				D[x:x+res,y:y+res] = b1
+ */
+        goto __pyx_L5_continue;
+
+        /* "prange_saliency_mbd.pyx":105
+ * 			b2 = max(u2,ix) - min(l2,ix)
+ * 
+ * 			if d <= b1 and d <= b2:             # <<<<<<<<<<<<<<
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:
+ */
+      }
+
+      /* "prange_saliency_mbd.pyx":107
+ * 			if d <= b1 and d <= b2:
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:             # <<<<<<<<<<<<<<
+ * 				D[x:x+res,y:y+res] = b1
+ * 				U[x:x+res,y:y+res] = max(u1,ix)
+ */
+      __pyx_t_17 = ((__pyx_v_b1 < __pyx_v_d) != 0);
+      if (__pyx_t_17) {
+      } else {
+        __pyx_t_16 = __pyx_t_17;
+        goto __pyx_L10_bool_binop_done;
+      }
+      __pyx_t_17 = ((__pyx_v_b1 <= __pyx_v_b2) != 0);
+      __pyx_t_16 = __pyx_t_17;
+      __pyx_L10_bool_binop_done:;
+      if (__pyx_t_16) {
+
+        /* "prange_saliency_mbd.pyx":108
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:
+ * 				D[x:x+res,y:y+res] = b1             # <<<<<<<<<<<<<<
+ * 				U[x:x+res,y:y+res] = max(u1,ix)
+ * 				L[x:x+res,y:y+res] = min(l1,ix)
+ */
+        __pyx_t_18.data = __pyx_v_D.data;
+        __pyx_t_18.memview = __pyx_v_D.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_D.shape[0], __pyx_v_D.strides[0], __pyx_v_D.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 108, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_D.shape[1], __pyx_v_D.strides[1], __pyx_v_D.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 108, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_v_b1;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":109
+ * 			elif b1 < d and b1 <= b2:
+ * 				D[x:x+res,y:y+res] = b1
+ * 				U[x:x+res,y:y+res] = max(u1,ix)             # <<<<<<<<<<<<<<
+ * 				L[x:x+res,y:y+res] = min(l1,ix)
+ * 			else:
+ */
+        __pyx_t_13 = __pyx_v_ix;
+        __pyx_t_12 = __pyx_v_u1;
+        if (((__pyx_t_13 > __pyx_t_12) != 0)) {
+          __pyx_t_15 = __pyx_t_13;
+        } else {
+          __pyx_t_15 = __pyx_t_12;
+        }
+        __pyx_t_18.data = __pyx_v_U.data;
+        __pyx_t_18.memview = __pyx_v_U.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_U.shape[0], __pyx_v_U.strides[0], __pyx_v_U.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 109, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_U.shape[1], __pyx_v_U.strides[1], __pyx_v_U.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 109, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_t_15;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":110
+ * 				D[x:x+res,y:y+res] = b1
+ * 				U[x:x+res,y:y+res] = max(u1,ix)
+ * 				L[x:x+res,y:y+res] = min(l1,ix)             # <<<<<<<<<<<<<<
+ * 			else:
+ * 				D[x:x+res,y:y+res] = b2
+ */
+        __pyx_t_15 = __pyx_v_ix;
+        __pyx_t_13 = __pyx_v_l1;
+        if (((__pyx_t_15 < __pyx_t_13) != 0)) {
+          __pyx_t_12 = __pyx_t_15;
+        } else {
+          __pyx_t_12 = __pyx_t_13;
+        }
+        __pyx_t_18.data = __pyx_v_L.data;
+        __pyx_t_18.memview = __pyx_v_L.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_L.shape[0], __pyx_v_L.strides[0], __pyx_v_L.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 110, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_L.shape[1], __pyx_v_L.strides[1], __pyx_v_L.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 110, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_t_12;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":107
+ * 			if d <= b1 and d <= b2:
+ * 				continue
+ * 			elif b1 < d and b1 <= b2:             # <<<<<<<<<<<<<<
+ * 				D[x:x+res,y:y+res] = b1
+ * 				U[x:x+res,y:y+res] = max(u1,ix)
+ */
+        goto __pyx_L7;
+      }
+
+      /* "prange_saliency_mbd.pyx":112
+ * 				L[x:x+res,y:y+res] = min(l1,ix)
+ * 			else:
+ * 				D[x:x+res,y:y+res] = b2             # <<<<<<<<<<<<<<
+ * 				U[x:x+res,y:y+res] = max(u2,ix)
+ * 				L[x:x+res,y:y+res] = min(l2,ix)
+ */
+      /*else*/ {
+        __pyx_t_18.data = __pyx_v_D.data;
+        __pyx_t_18.memview = __pyx_v_D.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_D.shape[0], __pyx_v_D.strides[0], __pyx_v_D.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 112, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_D.shape[1], __pyx_v_D.strides[1], __pyx_v_D.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 112, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_v_b2;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":113
+ * 			else:
+ * 				D[x:x+res,y:y+res] = b2
+ * 				U[x:x+res,y:y+res] = max(u2,ix)             # <<<<<<<<<<<<<<
+ * 				L[x:x+res,y:y+res] = min(l2,ix)
+ * 
+ */
+        __pyx_t_12 = __pyx_v_ix;
+        __pyx_t_15 = __pyx_v_u2;
+        if (((__pyx_t_12 > __pyx_t_15) != 0)) {
+          __pyx_t_13 = __pyx_t_12;
+        } else {
+          __pyx_t_13 = __pyx_t_15;
+        }
+        __pyx_t_18.data = __pyx_v_U.data;
+        __pyx_t_18.memview = __pyx_v_U.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_U.shape[0], __pyx_v_U.strides[0], __pyx_v_U.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 113, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_U.shape[1], __pyx_v_U.strides[1], __pyx_v_U.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 113, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_t_13;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+
+        /* "prange_saliency_mbd.pyx":114
+ * 				D[x:x+res,y:y+res] = b2
+ * 				U[x:x+res,y:y+res] = max(u2,ix)
+ * 				L[x:x+res,y:y+res] = min(l2,ix)             # <<<<<<<<<<<<<<
+ * 
+ * 	return True
+ */
+        __pyx_t_13 = __pyx_v_ix;
+        __pyx_t_12 = __pyx_v_l2;
+        if (((__pyx_t_13 < __pyx_t_12) != 0)) {
+          __pyx_t_15 = __pyx_t_13;
+        } else {
+          __pyx_t_15 = __pyx_t_12;
+        }
+        __pyx_t_18.data = __pyx_v_L.data;
+        __pyx_t_18.memview = __pyx_v_L.memview;
+        __PYX_INC_MEMVIEW(&__pyx_t_18, 0);
+        __pyx_t_19 = -1;
+        if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_L.shape[0], __pyx_v_L.strides[0], __pyx_v_L.suboffsets[0],
+    0,
+    0,
+    &__pyx_t_19,
+    __pyx_v_x,
+    (__pyx_v_x + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 114, __pyx_L1_error)
+}
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &__pyx_t_18,
+    __pyx_v_L.shape[1], __pyx_v_L.strides[1], __pyx_v_L.suboffsets[1],
+    1,
+    1,
+    &__pyx_t_19,
+    __pyx_v_y,
+    (__pyx_v_y + __pyx_v_res),
+    0,
+    1,
+    1,
+    0,
+    1) < 0))
+{
+    __PYX_ERR(0, 114, __pyx_L1_error)
+}
+
+{
+            double __pyx_temp_scalar = __pyx_t_15;
+            {
+                Py_ssize_t __pyx_temp_extent_0 = __pyx_t_18.shape[0];
+                Py_ssize_t __pyx_temp_stride_0 = __pyx_t_18.strides[0];
+                char *__pyx_temp_pointer_0;
+                Py_ssize_t __pyx_temp_idx_0;
+                Py_ssize_t __pyx_temp_extent_1 = __pyx_t_18.shape[1];
+                Py_ssize_t __pyx_temp_stride_1 = __pyx_t_18.strides[1];
+                char *__pyx_temp_pointer_1;
+                Py_ssize_t __pyx_temp_idx_1;
+                __pyx_temp_pointer_0 = __pyx_t_18.data;
+                for (__pyx_temp_idx_0 = 0; __pyx_temp_idx_0 < __pyx_temp_extent_0; __pyx_temp_idx_0++) {
+                  __pyx_temp_pointer_1 = __pyx_temp_pointer_0;
+                  for (__pyx_temp_idx_1 = 0; __pyx_temp_idx_1 < __pyx_temp_extent_1; __pyx_temp_idx_1++) {
+                    *((double *) __pyx_temp_pointer_1) = __pyx_temp_scalar;
+                    __pyx_temp_pointer_1 += __pyx_temp_stride_1;
+                  }
+                  __pyx_temp_pointer_0 += __pyx_temp_stride_0;
+                }
+            }
+        }
+        __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+        __pyx_t_18.memview = NULL;
+        __pyx_t_18.data = NULL;
+      }
+      __pyx_L7:;
+
+      /* "prange_saliency_mbd.pyx":85
+ * 	cdef int r2 = res//2
+ * 	for x in xrange(n_rows - 2 - res,1,-1*res):
+ * 		for y in xrange(n_cols - 2 - res,1,-1*res):             # <<<<<<<<<<<<<<
+ * 
+ * 			# ix = np.min(img[x:x+res,y:y+res])
+ */
+      __pyx_L5_continue:;
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    /* "prange_saliency_mbd.pyx":84
+ * 	cdef double b2
+ * 	cdef int r2 = res//2
+ * 	for x in xrange(n_rows - 2 - res,1,-1*res):             # <<<<<<<<<<<<<<
+ * 		for y in xrange(n_cols - 2 - res,1,-1*res):
+ * 
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "prange_saliency_mbd.pyx":116
+ * 				L[x:x+res,y:y+res] = min(l2,ix)
+ * 
+ * 	return True             # <<<<<<<<<<<<<<
+ * 
+ * @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(Py_True);
+  __pyx_r = Py_True;
+  goto __pyx_L0;
+
+  /* "prange_saliency_mbd.pyx":67
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cdef raster_scan_inv(double [:,:] img, double [:,:] L, double [:,:] U, double [:,:] D, int res):             # <<<<<<<<<<<<<<
+ * 	cdef int n_rows
+ * 	cdef int n_cols
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_7);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
+  __Pyx_AddTraceback("prange_saliency_mbd.raster_scan_inv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "prange_saliency_mbd.pyx":120
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters, int res):             # <<<<<<<<<<<<<<
+ * 	cdef double [:,:] L = img[...]
+ * 	cdef double [:,:] U = img[...]
+ */
+
+static PyObject *__pyx_f_19prange_saliency_mbd_mbd(PyArrayObject *__pyx_v_img, int __pyx_v_num_iters, int __pyx_v_res) {
+  __Pyx_memviewslice __pyx_v_L = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_v_U = { 0, 0, { 0 }, { 0 }, { 0 } };
+  PyArrayObject *__pyx_v_D = 0;
+  int __pyx_v_x;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_D;
+  __Pyx_Buffer __pyx_pybuffer_D;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_img;
+  __Pyx_Buffer __pyx_pybuffer_img;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("mbd", 0);
+  __pyx_pybuffer_D.pybuffer.buf = NULL;
+  __pyx_pybuffer_D.refcount = 0;
+  __pyx_pybuffernd_D.data = NULL;
+  __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D;
+  __pyx_pybuffer_img.pybuffer.buf = NULL;
+  __pyx_pybuffer_img.refcount = 0;
+  __pyx_pybuffernd_img.data = NULL;
+  __pyx_pybuffernd_img.rcbuffer = &__pyx_pybuffer_img;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img.rcbuffer->pybuffer, (PyObject*)__pyx_v_img, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 120, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_img.diminfo[0].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img.diminfo[0].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img.diminfo[1].strides = __pyx_pybuffernd_img.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img.diminfo[1].shape = __pyx_pybuffernd_img.rcbuffer->pybuffer.shape[1];
+
+  /* "prange_saliency_mbd.pyx":121
+ * @cython.wraparound(False)
+ * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters, int res):
+ * 	cdef double [:,:] L = img[...]             # <<<<<<<<<<<<<<
+ * 	cdef double [:,:] U = img[...]
+ * 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img), Py_Ellipsis); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 121, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_L = __pyx_t_2;
+  __pyx_t_2.memview = NULL;
+  __pyx_t_2.data = NULL;
+
+  /* "prange_saliency_mbd.pyx":122
+ * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters, int res):
+ * 	cdef double [:,:] L = img[...]
+ * 	cdef double [:,:] U = img[...]             # <<<<<<<<<<<<<<
+ * 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
+ * 	D[0,:] = 0
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img), Py_Ellipsis); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_U = __pyx_t_2;
+  __pyx_t_2.memview = NULL;
+  __pyx_t_2.data = NULL;
+
+  /* "prange_saliency_mbd.pyx":123
+ * 	cdef double [:,:] L = img[...]
+ * 	cdef double [:,:] U = img[...]
+ * 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)             # <<<<<<<<<<<<<<
+ * 	D[0,:] = 0
+ * 	D[-1,:] = 0
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_full_like); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_img), __pyx_int_10000000};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, ((PyObject *)__pyx_v_img), __pyx_int_10000000};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else
+  #endif
+  {
+    __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_INCREF(((PyObject *)__pyx_v_img));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_img));
+    PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_img));
+    __Pyx_INCREF(__pyx_int_10000000);
+    __Pyx_GIVEREF(__pyx_int_10000000);
+    PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_int_10000000);
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 123, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_D = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_D.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 123, __pyx_L1_error)
+    } else {__pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_D = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":124
+ * 	cdef double [:,:] U = img[...]
+ * 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
+ * 	D[0,:] = 0             # <<<<<<<<<<<<<<
+ * 	D[-1,:] = 0
+ * 	D[:,0] = 0
+ */
+  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__2, __pyx_int_0) < 0)) __PYX_ERR(0, 124, __pyx_L1_error)
+
+  /* "prange_saliency_mbd.pyx":125
+ * 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
+ * 	D[0,:] = 0
+ * 	D[-1,:] = 0             # <<<<<<<<<<<<<<
+ * 	D[:,0] = 0
+ * 	D[:,-1] = 0
+ */
+  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__3, __pyx_int_0) < 0)) __PYX_ERR(0, 125, __pyx_L1_error)
+
+  /* "prange_saliency_mbd.pyx":126
+ * 	D[0,:] = 0
+ * 	D[-1,:] = 0
+ * 	D[:,0] = 0             # <<<<<<<<<<<<<<
+ * 	D[:,-1] = 0
+ * 
+ */
+  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__4, __pyx_int_0) < 0)) __PYX_ERR(0, 126, __pyx_L1_error)
+
+  /* "prange_saliency_mbd.pyx":127
+ * 	D[-1,:] = 0
+ * 	D[:,0] = 0
+ * 	D[:,-1] = 0             # <<<<<<<<<<<<<<
+ * 
+ * 	cdef int x
+ */
+  if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_D), __pyx_tuple__5, __pyx_int_0) < 0)) __PYX_ERR(0, 127, __pyx_L1_error)
+
+  /* "prange_saliency_mbd.pyx":130
+ * 
+ * 	cdef int x
+ * 	for x in xrange(0,num_iters):             # <<<<<<<<<<<<<<
+ * 		if x%2 == 1:
+ * 			raster_scan(img,L,U,D,res)
+ */
+  __pyx_t_5 = __pyx_v_num_iters;
+  __pyx_t_8 = __pyx_t_5;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) {
+    __pyx_v_x = __pyx_t_9;
+
+    /* "prange_saliency_mbd.pyx":131
+ * 	cdef int x
+ * 	for x in xrange(0,num_iters):
+ * 		if x%2 == 1:             # <<<<<<<<<<<<<<
+ * 			raster_scan(img,L,U,D,res)
+ * 		else:
+ */
+    __pyx_t_10 = ((__Pyx_mod_long(__pyx_v_x, 2) == 1) != 0);
+    if (__pyx_t_10) {
+
+      /* "prange_saliency_mbd.pyx":132
+ * 	for x in xrange(0,num_iters):
+ * 		if x%2 == 1:
+ * 			raster_scan(img,L,U,D,res)             # <<<<<<<<<<<<<<
+ * 		else:
+ * 			raster_scan_inv(img,L,U,D,res)
+ */
+      __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_img), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 132, __pyx_L1_error)
+      __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_D), PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 132, __pyx_L1_error)
+      __pyx_t_1 = __pyx_f_19prange_saliency_mbd_raster_scan(__pyx_t_2, __pyx_v_L, __pyx_v_U, __pyx_t_11, __pyx_v_res); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __PYX_XDEC_MEMVIEW(&__pyx_t_2, 1);
+      __pyx_t_2.memview = NULL;
+      __pyx_t_2.data = NULL;
+      __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
+      __pyx_t_11.memview = NULL;
+      __pyx_t_11.data = NULL;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      /* "prange_saliency_mbd.pyx":131
+ * 	cdef int x
+ * 	for x in xrange(0,num_iters):
+ * 		if x%2 == 1:             # <<<<<<<<<<<<<<
+ * 			raster_scan(img,L,U,D,res)
+ * 		else:
+ */
+      goto __pyx_L5;
+    }
+
+    /* "prange_saliency_mbd.pyx":134
+ * 			raster_scan(img,L,U,D,res)
+ * 		else:
+ * 			raster_scan_inv(img,L,U,D,res)             # <<<<<<<<<<<<<<
+ * 
+ * 	return D
+ */
+    /*else*/ {
+      __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_img), PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 134, __pyx_L1_error)
+      __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_D), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 134, __pyx_L1_error)
+      __pyx_t_1 = __pyx_f_19prange_saliency_mbd_raster_scan_inv(__pyx_t_11, __pyx_v_L, __pyx_v_U, __pyx_t_2, __pyx_v_res); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
+      __pyx_t_11.memview = NULL;
+      __pyx_t_11.data = NULL;
+      __PYX_XDEC_MEMVIEW(&__pyx_t_2, 1);
+      __pyx_t_2.memview = NULL;
+      __pyx_t_2.data = NULL;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __pyx_L5:;
+  }
+
+  /* "prange_saliency_mbd.pyx":136
+ * 			raster_scan_inv(img,L,U,D,res)
+ * 
+ * 	return D             # <<<<<<<<<<<<<<
+ * 
+ * cdef mbd_1(val, n_cols, border_thickness):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_D));
+  __pyx_r = ((PyObject *)__pyx_v_D);
+  goto __pyx_L0;
+
+  /* "prange_saliency_mbd.pyx":120
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cdef mbd(np.ndarray[double, ndim=2] img, int num_iters, int res):             # <<<<<<<<<<<<<<
+ * 	cdef double [:,:] L = img[...]
+ * 	cdef double [:,:] U = img[...]
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_2, 1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("prange_saliency_mbd.mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __PYX_XDEC_MEMVIEW(&__pyx_v_L, 1);
+  __PYX_XDEC_MEMVIEW(&__pyx_v_U, 1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_D);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "prange_saliency_mbd.pyx":138
+ * 	return D
+ * 
+ * cdef mbd_1(val, n_cols, border_thickness):             # <<<<<<<<<<<<<<
+ * 	x, v2 = val
+ * 	px, cov, px_mean = v2
+ */
+
+static PyObject *__pyx_f_19prange_saliency_mbd_mbd_1(PyObject *__pyx_v_val, PyObject *__pyx_v_n_cols, PyObject *__pyx_v_border_thickness) {
+  PyObject *__pyx_v_x = NULL;
+  PyObject *__pyx_v_v2 = NULL;
+  PyObject *__pyx_v_px = NULL;
+  PyObject *__pyx_v_cov = NULL;
+  PyObject *__pyx_v_px_mean = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("mbd_1", 0);
+
+  /* "prange_saliency_mbd.pyx":139
+ * 
+ * cdef mbd_1(val, n_cols, border_thickness):
+ * 	x, v2 = val             # <<<<<<<<<<<<<<
+ * 	px, cov, px_mean = v2
+ * 	px_mean[x] = np.mean(px[x],axis=(0,1))
+ */
+  if ((likely(PyTuple_CheckExact(__pyx_v_val))) || (PyList_CheckExact(__pyx_v_val))) {
+    PyObject* sequence = __pyx_v_val;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 139, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_t_2);
+    #else
+    __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    #endif
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_3 = PyObject_GetIter(__pyx_v_val); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 139, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = Py_TYPE(__pyx_t_3)->tp_iternext;
+    index = 0; __pyx_t_1 = __pyx_t_4(__pyx_t_3); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    index = 1; __pyx_t_2 = __pyx_t_4(__pyx_t_3); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_4(__pyx_t_3), 2) < 0) __PYX_ERR(0, 139, __pyx_L1_error)
+    __pyx_t_4 = NULL;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 139, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_v_x = __pyx_t_1;
+  __pyx_t_1 = 0;
+  __pyx_v_v2 = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "prange_saliency_mbd.pyx":140
+ * cdef mbd_1(val, n_cols, border_thickness):
+ * 	x, v2 = val
+ * 	px, cov, px_mean = v2             # <<<<<<<<<<<<<<
+ * 	px_mean[x] = np.mean(px[x],axis=(0,1))
+ * 	px[x] = px[x].reshape((n_cols*border_thickness,3))
+ */
+  if ((likely(PyTuple_CheckExact(__pyx_v_v2))) || (PyList_CheckExact(__pyx_v_v2))) {
+    PyObject* sequence = __pyx_v_v2;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 140, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 140, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 140, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_5 = PyObject_GetIter(__pyx_v_v2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 140, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_4 = Py_TYPE(__pyx_t_5)->tp_iternext;
+    index = 0; __pyx_t_2 = __pyx_t_4(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    index = 1; __pyx_t_1 = __pyx_t_4(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    index = 2; __pyx_t_3 = __pyx_t_4(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_4(__pyx_t_5), 3) < 0) __PYX_ERR(0, 140, __pyx_L1_error)
+    __pyx_t_4 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L6_unpacking_done;
+    __pyx_L5_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_4 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 140, __pyx_L1_error)
+    __pyx_L6_unpacking_done:;
+  }
+  __pyx_v_px = __pyx_t_2;
+  __pyx_t_2 = 0;
+  __pyx_v_cov = __pyx_t_1;
+  __pyx_t_1 = 0;
+  __pyx_v_px_mean = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "prange_saliency_mbd.pyx":141
+ * 	x, v2 = val
+ * 	px, cov, px_mean = v2
+ * 	px_mean[x] = np.mean(px[x],axis=(0,1))             # <<<<<<<<<<<<<<
+ * 	px[x] = px[x].reshape((n_cols*border_thickness,3))
+ * 	cov[x] =  np.linalg.inv(np.cov(px[x].T))
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_px, __pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 141, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(PyObject_SetItem(__pyx_v_px_mean, __pyx_v_x, __pyx_t_5) < 0)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "prange_saliency_mbd.pyx":142
+ * 	px, cov, px_mean = v2
+ * 	px_mean[x] = np.mean(px[x],axis=(0,1))
+ * 	px[x] = px[x].reshape((n_cols*border_thickness,3))             # <<<<<<<<<<<<<<
+ * 	cov[x] =  np.linalg.inv(np.cov(px[x].T))
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_px, __pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_reshape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Multiply(__pyx_v_n_cols, __pyx_v_border_thickness); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(PyObject_SetItem(__pyx_v_px, __pyx_v_x, __pyx_t_5) < 0)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "prange_saliency_mbd.pyx":143
+ * 	px_mean[x] = np.mean(px[x],axis=(0,1))
+ * 	px[x] = px[x].reshape((n_cols*border_thickness,3))
+ * 	cov[x] =  np.linalg.inv(np.cov(px[x].T))             # <<<<<<<<<<<<<<
+ * 
+ * cdef f(x):
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_linalg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inv); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cov); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_px, __pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_T); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_3, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(PyObject_SetItem(__pyx_v_cov, __pyx_v_x, __pyx_t_5) < 0)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  /* "prange_saliency_mbd.pyx":138
+ * 	return D
+ * 
+ * cdef mbd_1(val, n_cols, border_thickness):             # <<<<<<<<<<<<<<
+ * 	x, v2 = val
+ * 	px, cov, px_mean = v2
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("prange_saliency_mbd.mbd_1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_x);
+  __Pyx_XDECREF(__pyx_v_v2);
+  __Pyx_XDECREF(__pyx_v_px);
+  __Pyx_XDECREF(__pyx_v_cov);
+  __Pyx_XDECREF(__pyx_v_px_mean);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "prange_saliency_mbd.pyx":145
+ * 	cov[x] =  np.linalg.inv(np.cov(px[x].T))
+ * 
+ * cdef f(x):             # <<<<<<<<<<<<<<
+ * 	b = 10.0
+ * 	return 1.0 / (1.0 + exp(-b*(x - 0.5)))
+ */
+
+static PyObject *__pyx_f_19prange_saliency_mbd_f(PyObject *__pyx_v_x) {
+  double __pyx_v_b;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  double __pyx_t_4;
+  double __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("f", 0);
+
+  /* "prange_saliency_mbd.pyx":146
+ * 
+ * cdef f(x):
+ * 	b = 10.0             # <<<<<<<<<<<<<<
+ * 	return 1.0 / (1.0 + exp(-b*(x - 0.5)))
+ * 
+ */
+  __pyx_v_b = 10.0;
+
+  /* "prange_saliency_mbd.pyx":147
+ * cdef f(x):
+ * 	b = 10.0
+ * 	return 1.0 / (1.0 + exp(-b*(x - 0.5)))             # <<<<<<<<<<<<<<
+ * 
+ * @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble((-__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyFloat_SubtractObjC(__pyx_v_x, __pyx_float_0_5, 0.5, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5 = (1.0 + exp(__pyx_t_4));
+  if (unlikely(__pyx_t_5 == 0)) {
+    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+    __PYX_ERR(0, 147, __pyx_L1_error)
+  }
+  __pyx_t_3 = PyFloat_FromDouble((1.0 / __pyx_t_5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "prange_saliency_mbd.pyx":145
+ * 	cov[x] =  np.linalg.inv(np.cov(px[x].T))
+ * 
+ * cdef f(x):             # <<<<<<<<<<<<<<
+ * 	b = 10.0
+ * 	return 1.0 / (1.0 + exp(-b*(x - 0.5)))
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("prange_saliency_mbd.f", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "prange_saliency_mbd.pyx":151
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef get_saliency_mbd(np.ndarray img,method='b', res = 2):             # <<<<<<<<<<<<<<
+ * 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
+ * 	img_mean = np.mean(img,axis=(2))
+ */
+
+static PyObject *__pyx_pw_19prange_saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyObject *__pyx_f_19prange_saliency_mbd_get_saliency_mbd(PyArrayObject *__pyx_v_img, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_19prange_saliency_mbd_get_saliency_mbd *__pyx_optional_args) {
+  PyObject *__pyx_v_res = ((PyObject *)__pyx_int_2);
+  PyObject *__pyx_v_img_mean = NULL;
+  PyObject *__pyx_v_sal = NULL;
+  int __pyx_v_n_rows;
+  int __pyx_v_n_cols;
+  CYTHON_UNUSED int __pyx_v_n_channels;
+  double __pyx_v_img_size;
+  PyObject *__pyx_v_border_thickness = 0;
+  PyArrayObject *__pyx_v_img_lab = 0;
+  PyArrayObject *__pyx_v_px_1 = 0;
+  PyArrayObject *__pyx_v_px_2 = 0;
+  PyArrayObject *__pyx_v_px_mean = 0;
+  PyArrayObject *__pyx_v_cov = 0;
+  PyArrayObject *__pyx_v_px_new_1 = 0;
+  PyArrayObject *__pyx_v_px_new_2 = 0;
+  PyArrayObject *__pyx_v_px = 0;
+  PyArrayObject *__pyx_v_px_new = 0;
+  Py_ssize_t __pyx_v_x;
+  PyArrayObject *__pyx_v_u = 0;
+  PyArrayObject *__pyx_v_img_lab_unrolled = 0;
+  PyArrayObject *__pyx_v_px_mean_2 = 0;
+  PyObject *__pyx_v_u_max = NULL;
+  PyObject *__pyx_v_u_final = NULL;
+  PyObject *__pyx_v_u_max_final = NULL;
+  PyObject *__pyx_v_sal_max = NULL;
+  PyObject *__pyx_v_s = NULL;
+  double __pyx_v_alpha;
+  CYTHON_UNUSED double __pyx_v_delta;
+  PyObject *__pyx_v_xv = NULL;
+  PyObject *__pyx_v_yv = NULL;
+  int __pyx_v_w;
+  int __pyx_v_h;
+  double __pyx_v_w2;
+  double __pyx_v_h2;
+  PyObject *__pyx_v_C = NULL;
+  PyObject *__pyx_v_fv = NULL;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_cov;
+  __Pyx_Buffer __pyx_pybuffer_cov;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_img_lab;
+  __Pyx_Buffer __pyx_pybuffer_img_lab;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_img_lab_unrolled;
+  __Pyx_Buffer __pyx_pybuffer_img_lab_unrolled;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_px;
+  __Pyx_Buffer __pyx_pybuffer_px;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_px_1;
+  __Pyx_Buffer __pyx_pybuffer_px_1;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_px_2;
+  __Pyx_Buffer __pyx_pybuffer_px_2;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_px_mean;
+  __Pyx_Buffer __pyx_pybuffer_px_mean;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_px_mean_2;
+  __Pyx_Buffer __pyx_pybuffer_px_mean_2;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_px_new;
+  __Pyx_Buffer __pyx_pybuffer_px_new;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_px_new_1;
+  __Pyx_Buffer __pyx_pybuffer_px_new_1;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_px_new_2;
+  __Pyx_Buffer __pyx_pybuffer_px_new_2;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_u;
+  __Pyx_Buffer __pyx_pybuffer_u;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  PyArrayObject *__pyx_t_9 = NULL;
+  PyArrayObject *__pyx_t_10 = NULL;
+  PyArrayObject *__pyx_t_11 = NULL;
+  PyArrayObject *__pyx_t_12 = NULL;
+  PyArrayObject *__pyx_t_13 = NULL;
+  Py_ssize_t __pyx_t_14;
+  int __pyx_t_15;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  Py_ssize_t __pyx_t_19;
+  PyObject *__pyx_t_20 = NULL;
+  PyArrayObject *__pyx_t_21 = NULL;
+  PyArrayObject *__pyx_t_22 = NULL;
+  PyArrayObject *__pyx_t_23 = NULL;
+  PyObject *__pyx_t_24 = NULL;
+  PyObject *__pyx_t_25 = NULL;
+  PyObject *__pyx_t_26 = NULL;
+  double __pyx_t_27;
+  PyObject *(*__pyx_t_28)(PyObject *);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_saliency_mbd", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 1) {
+      __pyx_v_res = __pyx_optional_args->res;
+    }
+  }
+  __pyx_pybuffer_img_lab.pybuffer.buf = NULL;
+  __pyx_pybuffer_img_lab.refcount = 0;
+  __pyx_pybuffernd_img_lab.data = NULL;
+  __pyx_pybuffernd_img_lab.rcbuffer = &__pyx_pybuffer_img_lab;
+  __pyx_pybuffer_px_1.pybuffer.buf = NULL;
+  __pyx_pybuffer_px_1.refcount = 0;
+  __pyx_pybuffernd_px_1.data = NULL;
+  __pyx_pybuffernd_px_1.rcbuffer = &__pyx_pybuffer_px_1;
+  __pyx_pybuffer_px_2.pybuffer.buf = NULL;
+  __pyx_pybuffer_px_2.refcount = 0;
+  __pyx_pybuffernd_px_2.data = NULL;
+  __pyx_pybuffernd_px_2.rcbuffer = &__pyx_pybuffer_px_2;
+  __pyx_pybuffer_px_mean.pybuffer.buf = NULL;
+  __pyx_pybuffer_px_mean.refcount = 0;
+  __pyx_pybuffernd_px_mean.data = NULL;
+  __pyx_pybuffernd_px_mean.rcbuffer = &__pyx_pybuffer_px_mean;
+  __pyx_pybuffer_cov.pybuffer.buf = NULL;
+  __pyx_pybuffer_cov.refcount = 0;
+  __pyx_pybuffernd_cov.data = NULL;
+  __pyx_pybuffernd_cov.rcbuffer = &__pyx_pybuffer_cov;
+  __pyx_pybuffer_px_new_1.pybuffer.buf = NULL;
+  __pyx_pybuffer_px_new_1.refcount = 0;
+  __pyx_pybuffernd_px_new_1.data = NULL;
+  __pyx_pybuffernd_px_new_1.rcbuffer = &__pyx_pybuffer_px_new_1;
+  __pyx_pybuffer_px_new_2.pybuffer.buf = NULL;
+  __pyx_pybuffer_px_new_2.refcount = 0;
+  __pyx_pybuffernd_px_new_2.data = NULL;
+  __pyx_pybuffernd_px_new_2.rcbuffer = &__pyx_pybuffer_px_new_2;
+  __pyx_pybuffer_px.pybuffer.buf = NULL;
+  __pyx_pybuffer_px.refcount = 0;
+  __pyx_pybuffernd_px.data = NULL;
+  __pyx_pybuffernd_px.rcbuffer = &__pyx_pybuffer_px;
+  __pyx_pybuffer_px_new.pybuffer.buf = NULL;
+  __pyx_pybuffer_px_new.refcount = 0;
+  __pyx_pybuffernd_px_new.data = NULL;
+  __pyx_pybuffernd_px_new.rcbuffer = &__pyx_pybuffer_px_new;
+  __pyx_pybuffer_u.pybuffer.buf = NULL;
+  __pyx_pybuffer_u.refcount = 0;
+  __pyx_pybuffernd_u.data = NULL;
+  __pyx_pybuffernd_u.rcbuffer = &__pyx_pybuffer_u;
+  __pyx_pybuffer_img_lab_unrolled.pybuffer.buf = NULL;
+  __pyx_pybuffer_img_lab_unrolled.refcount = 0;
+  __pyx_pybuffernd_img_lab_unrolled.data = NULL;
+  __pyx_pybuffernd_img_lab_unrolled.rcbuffer = &__pyx_pybuffer_img_lab_unrolled;
+  __pyx_pybuffer_px_mean_2.pybuffer.buf = NULL;
+  __pyx_pybuffer_px_mean_2.refcount = 0;
+  __pyx_pybuffernd_px_mean_2.data = NULL;
+  __pyx_pybuffernd_px_mean_2.rcbuffer = &__pyx_pybuffer_px_mean_2;
+
+  /* "prange_saliency_mbd.pyx":153
+ * cpdef get_saliency_mbd(np.ndarray img,method='b', res = 2):
+ * 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
+ * 	img_mean = np.mean(img,axis=(2))             # <<<<<<<<<<<<<<
+ * 	sal = mbd(img_mean,2, res)
+ * 	cdef int n_rows = img.shape[0]
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_mean); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_img));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_img));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_img));
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_axis, __pyx_int_2) < 0) __PYX_ERR(0, 153, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_img_mean = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "prange_saliency_mbd.pyx":154
+ * 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
+ * 	img_mean = np.mean(img,axis=(2))
+ * 	sal = mbd(img_mean,2, res)             # <<<<<<<<<<<<<<
+ * 	cdef int n_rows = img.shape[0]
+ * 	cdef int n_cols = img.shape[1]
+ */
+  if (!(likely(((__pyx_v_img_mean) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_img_mean, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 154, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_res); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L1_error)
+  __pyx_t_4 = __pyx_f_19prange_saliency_mbd_mbd(((PyArrayObject *)__pyx_v_img_mean), 2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_sal = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "prange_saliency_mbd.pyx":155
+ * 	img_mean = np.mean(img,axis=(2))
+ * 	sal = mbd(img_mean,2, res)
+ * 	cdef int n_rows = img.shape[0]             # <<<<<<<<<<<<<<
+ * 	cdef int n_cols = img.shape[1]
+ * 	cdef int n_channels = img.shape[2]
+ */
+  __pyx_v_n_rows = (__pyx_v_img->dimensions[0]);
+
+  /* "prange_saliency_mbd.pyx":156
+ * 	sal = mbd(img_mean,2, res)
+ * 	cdef int n_rows = img.shape[0]
+ * 	cdef int n_cols = img.shape[1]             # <<<<<<<<<<<<<<
+ * 	cdef int n_channels = img.shape[2]
+ * 	cdef double img_size = sqrt(n_rows * n_cols)
+ */
+  __pyx_v_n_cols = (__pyx_v_img->dimensions[1]);
+
+  /* "prange_saliency_mbd.pyx":157
+ * 	cdef int n_rows = img.shape[0]
+ * 	cdef int n_cols = img.shape[1]
+ * 	cdef int n_channels = img.shape[2]             # <<<<<<<<<<<<<<
+ * 	cdef double img_size = sqrt(n_rows * n_cols)
+ * 	cdef border_thickness = int(floor(0.1 * img_size))
+ */
+  __pyx_v_n_channels = (__pyx_v_img->dimensions[2]);
+
+  /* "prange_saliency_mbd.pyx":158
+ * 	cdef int n_cols = img.shape[1]
+ * 	cdef int n_channels = img.shape[2]
+ * 	cdef double img_size = sqrt(n_rows * n_cols)             # <<<<<<<<<<<<<<
+ * 	cdef border_thickness = int(floor(0.1 * img_size))
+ * 	cdef np.ndarray[double,ndim=3] img_lab = img_as_float(skimage.color.rgb2lab(img))
+ */
+  __pyx_v_img_size = sqrt((__pyx_v_n_rows * __pyx_v_n_cols));
+
+  /* "prange_saliency_mbd.pyx":159
+ * 	cdef int n_channels = img.shape[2]
+ * 	cdef double img_size = sqrt(n_rows * n_cols)
+ * 	cdef border_thickness = int(floor(0.1 * img_size))             # <<<<<<<<<<<<<<
+ * 	cdef np.ndarray[double,ndim=3] img_lab = img_as_float(skimage.color.rgb2lab(img))
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyInt_FromDouble(floor((0.1 * __pyx_v_img_size))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_border_thickness = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "prange_saliency_mbd.pyx":160
+ * 	cdef double img_size = sqrt(n_rows * n_cols)
+ * 	cdef border_thickness = int(floor(0.1 * img_size))
+ * 	cdef np.ndarray[double,ndim=3] img_lab = img_as_float(skimage.color.rgb2lab(img))             # <<<<<<<<<<<<<<
+ * 
+ * 	## Process Left right
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_skimage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_color); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_rgb2lab); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, ((PyObject *)__pyx_v_img)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_img));
+  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 160, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_4);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img_lab.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
+      __pyx_v_img_lab = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_img_lab.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 160, __pyx_L1_error)
+    } else {__pyx_pybuffernd_img_lab.diminfo[0].strides = __pyx_pybuffernd_img_lab.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img_lab.diminfo[0].shape = __pyx_pybuffernd_img_lab.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img_lab.diminfo[1].strides = __pyx_pybuffernd_img_lab.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img_lab.diminfo[1].shape = __pyx_pybuffernd_img_lab.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_img_lab.diminfo[2].strides = __pyx_pybuffernd_img_lab.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_img_lab.diminfo[2].shape = __pyx_pybuffernd_img_lab.rcbuffer->pybuffer.shape[2];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_img_lab = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "prange_saliency_mbd.pyx":163
+ * 
+ * 	## Process Left right
+ * 	cdef np.ndarray[double,ndim=4] px_1 = np.empty((2,border_thickness,img_lab.shape[1], img_lab.shape[2]))             # <<<<<<<<<<<<<<
+ * 	px_1[0] = img_lab[0:border_thickness,:,:]
+ * 	px_1[1] = img_lab[n_rows - border_thickness-1:-1,:,:]
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_INCREF(__pyx_int_2);
+  __Pyx_GIVEREF(__pyx_int_2);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_2);
+  __Pyx_INCREF(__pyx_v_border_thickness);
+  __Pyx_GIVEREF(__pyx_v_border_thickness);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_border_thickness);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2);
+  __pyx_t_3 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 163, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_4);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_1.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack) == -1)) {
+      __pyx_v_px_1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_px_1.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 163, __pyx_L1_error)
+    } else {__pyx_pybuffernd_px_1.diminfo[0].strides = __pyx_pybuffernd_px_1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px_1.diminfo[0].shape = __pyx_pybuffernd_px_1.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px_1.diminfo[1].strides = __pyx_pybuffernd_px_1.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px_1.diminfo[1].shape = __pyx_pybuffernd_px_1.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px_1.diminfo[2].strides = __pyx_pybuffernd_px_1.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px_1.diminfo[2].shape = __pyx_pybuffernd_px_1.rcbuffer->pybuffer.shape[2]; __pyx_pybuffernd_px_1.diminfo[3].strides = __pyx_pybuffernd_px_1.rcbuffer->pybuffer.strides[3]; __pyx_pybuffernd_px_1.diminfo[3].shape = __pyx_pybuffernd_px_1.rcbuffer->pybuffer.shape[3];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_px_1 = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "prange_saliency_mbd.pyx":164
+ * 	## Process Left right
+ * 	cdef np.ndarray[double,ndim=4] px_1 = np.empty((2,border_thickness,img_lab.shape[1], img_lab.shape[2]))
+ * 	px_1[0] = img_lab[0:border_thickness,:,:]             # <<<<<<<<<<<<<<
+ * 	px_1[1] = img_lab[n_rows - border_thickness-1:-1,:,:]
+ * 
+ */
+  __pyx_t_4 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_slice_);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_slice_);
+  __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_px_1), 0, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 0) < 0)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "prange_saliency_mbd.pyx":165
+ * 	cdef np.ndarray[double,ndim=4] px_1 = np.empty((2,border_thickness,img_lab.shape[1], img_lab.shape[2]))
+ * 	px_1[0] = img_lab[0:border_thickness,:,:]
+ * 	px_1[1] = img_lab[n_rows - border_thickness-1:-1,:,:]             # <<<<<<<<<<<<<<
+ * 
+ * 	## Process Top bottom
+ */
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = PyNumber_Subtract(__pyx_t_4, __pyx_v_border_thickness); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PySlice_New(__pyx_t_4, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_slice_);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_slice_);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_px_1), 1, __pyx_t_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0) < 0)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":168
+ * 
+ * 	## Process Top bottom
+ * 	cdef np.ndarray[double,ndim=4] px_2= np.empty((2,img_lab.shape[0],border_thickness,img_lab.shape[2]))             # <<<<<<<<<<<<<<
+ * 	px_2[0] = img_lab[:,0:border_thickness,:]
+ * 	px_2[1] = img_lab[:,n_cols - border_thickness-1:-1,:]
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_int_2);
+  __Pyx_GIVEREF(__pyx_int_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __Pyx_INCREF(__pyx_v_border_thickness);
+  __Pyx_GIVEREF(__pyx_v_border_thickness);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_border_thickness);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2);
+  __pyx_t_4 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 168, __pyx_L1_error)
+  __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_2.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack) == -1)) {
+      __pyx_v_px_2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_px_2.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 168, __pyx_L1_error)
+    } else {__pyx_pybuffernd_px_2.diminfo[0].strides = __pyx_pybuffernd_px_2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px_2.diminfo[0].shape = __pyx_pybuffernd_px_2.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px_2.diminfo[1].strides = __pyx_pybuffernd_px_2.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px_2.diminfo[1].shape = __pyx_pybuffernd_px_2.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px_2.diminfo[2].strides = __pyx_pybuffernd_px_2.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px_2.diminfo[2].shape = __pyx_pybuffernd_px_2.rcbuffer->pybuffer.shape[2]; __pyx_pybuffernd_px_2.diminfo[3].strides = __pyx_pybuffernd_px_2.rcbuffer->pybuffer.strides[3]; __pyx_pybuffernd_px_2.diminfo[3].shape = __pyx_pybuffernd_px_2.rcbuffer->pybuffer.shape[3];
+    }
+  }
+  __pyx_t_9 = 0;
+  __pyx_v_px_2 = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":169
+ * 	## Process Top bottom
+ * 	cdef np.ndarray[double,ndim=4] px_2= np.empty((2,img_lab.shape[0],border_thickness,img_lab.shape[2]))
+ * 	px_2[0] = img_lab[:,0:border_thickness,:]             # <<<<<<<<<<<<<<
+ * 	px_2[1] = img_lab[:,n_cols - border_thickness-1:-1,:]
+ * 
+ */
+  __pyx_t_1 = PySlice_New(__pyx_int_0, __pyx_v_border_thickness, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_slice_);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_slice_);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_px_2), 0, __pyx_t_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0) < 0)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":170
+ * 	cdef np.ndarray[double,ndim=4] px_2= np.empty((2,img_lab.shape[0],border_thickness,img_lab.shape[2]))
+ * 	px_2[0] = img_lab[:,0:border_thickness,:]
+ * 	px_2[1] = img_lab[:,n_cols - border_thickness-1:-1,:]             # <<<<<<<<<<<<<<
+ * 
+ * 	## Combine into one array for easy access
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = PyNumber_Subtract(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_t_6, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = PySlice_New(__pyx_t_1, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_slice_);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6);
+  __Pyx_INCREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_slice_);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_img_lab), __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_px_2), 1, __pyx_t_6, long, 1, __Pyx_PyInt_From_long, 0, 0, 0) < 0)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "prange_saliency_mbd.pyx":175
+ * 	# cdef px = [px_1,px_2]
+ * 
+ * 	cdef  np.ndarray[double,ndim=2] px_mean = np.empty((4,3)) ## np.ndarray[double,ndim=2]             # <<<<<<<<<<<<<<
+ * 	cdef  np.ndarray[double,ndim=3] cov = np.empty((4,3,3))
+ * 	cdef np.ndarray[double,ndim=3] px_new_1 = np.empty((2, n_cols*border_thickness,3))
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_6 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_tuple__7) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_tuple__7);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 175, __pyx_L1_error)
+  __pyx_t_10 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_mean.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_px_mean = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_px_mean.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 175, __pyx_L1_error)
+    } else {__pyx_pybuffernd_px_mean.diminfo[0].strides = __pyx_pybuffernd_px_mean.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px_mean.diminfo[0].shape = __pyx_pybuffernd_px_mean.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px_mean.diminfo[1].strides = __pyx_pybuffernd_px_mean.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px_mean.diminfo[1].shape = __pyx_pybuffernd_px_mean.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_10 = 0;
+  __pyx_v_px_mean = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "prange_saliency_mbd.pyx":176
+ * 
+ * 	cdef  np.ndarray[double,ndim=2] px_mean = np.empty((4,3)) ## np.ndarray[double,ndim=2]
+ * 	cdef  np.ndarray[double,ndim=3] cov = np.empty((4,3,3))             # <<<<<<<<<<<<<<
+ * 	cdef np.ndarray[double,ndim=3] px_new_1 = np.empty((2, n_cols*border_thickness,3))
+ * 	cdef np.ndarray[double,ndim=3] px_new_2  = np.empty((2, n_rows*border_thickness,3))
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_6 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_tuple__8) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_tuple__8);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 176, __pyx_L1_error)
+  __pyx_t_11 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_cov.rcbuffer->pybuffer, (PyObject*)__pyx_t_11, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
+      __pyx_v_cov = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_cov.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 176, __pyx_L1_error)
+    } else {__pyx_pybuffernd_cov.diminfo[0].strides = __pyx_pybuffernd_cov.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_cov.diminfo[0].shape = __pyx_pybuffernd_cov.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_cov.diminfo[1].strides = __pyx_pybuffernd_cov.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_cov.diminfo[1].shape = __pyx_pybuffernd_cov.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_cov.diminfo[2].strides = __pyx_pybuffernd_cov.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_cov.diminfo[2].shape = __pyx_pybuffernd_cov.rcbuffer->pybuffer.shape[2];
+    }
+  }
+  __pyx_t_11 = 0;
+  __pyx_v_cov = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "prange_saliency_mbd.pyx":177
+ * 	cdef  np.ndarray[double,ndim=2] px_mean = np.empty((4,3)) ## np.ndarray[double,ndim=2]
+ * 	cdef  np.ndarray[double,ndim=3] cov = np.empty((4,3,3))
+ * 	cdef np.ndarray[double,ndim=3] px_new_1 = np.empty((2, n_cols*border_thickness,3))             # <<<<<<<<<<<<<<
+ * 	cdef np.ndarray[double,ndim=3] px_new_2  = np.empty((2, n_rows*border_thickness,3))
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_int_2);
+  __Pyx_GIVEREF(__pyx_int_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_int_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_int_3);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_6 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 177, __pyx_L1_error)
+  __pyx_t_12 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_new_1.rcbuffer->pybuffer, (PyObject*)__pyx_t_12, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
+      __pyx_v_px_new_1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_px_new_1.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 177, __pyx_L1_error)
+    } else {__pyx_pybuffernd_px_new_1.diminfo[0].strides = __pyx_pybuffernd_px_new_1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px_new_1.diminfo[0].shape = __pyx_pybuffernd_px_new_1.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px_new_1.diminfo[1].strides = __pyx_pybuffernd_px_new_1.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px_new_1.diminfo[1].shape = __pyx_pybuffernd_px_new_1.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px_new_1.diminfo[2].strides = __pyx_pybuffernd_px_new_1.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px_new_1.diminfo[2].shape = __pyx_pybuffernd_px_new_1.rcbuffer->pybuffer.shape[2];
+    }
+  }
+  __pyx_t_12 = 0;
+  __pyx_v_px_new_1 = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "prange_saliency_mbd.pyx":178
+ * 	cdef  np.ndarray[double,ndim=3] cov = np.empty((4,3,3))
+ * 	cdef np.ndarray[double,ndim=3] px_new_1 = np.empty((2, n_cols*border_thickness,3))
+ * 	cdef np.ndarray[double,ndim=3] px_new_2  = np.empty((2, n_rows*border_thickness,3))             # <<<<<<<<<<<<<<
+ * 
+ * 	#TODO: work on prange implementation to not use numpy (to circumvent GIL)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_v_border_thickness); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_int_2);
+  __Pyx_GIVEREF(__pyx_int_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_int_3);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  __pyx_t_6 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 178, __pyx_L1_error)
+  __pyx_t_13 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_new_2.rcbuffer->pybuffer, (PyObject*)__pyx_t_13, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
+      __pyx_v_px_new_2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_px_new_2.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 178, __pyx_L1_error)
+    } else {__pyx_pybuffernd_px_new_2.diminfo[0].strides = __pyx_pybuffernd_px_new_2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px_new_2.diminfo[0].shape = __pyx_pybuffernd_px_new_2.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px_new_2.diminfo[1].strides = __pyx_pybuffernd_px_new_2.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px_new_2.diminfo[1].shape = __pyx_pybuffernd_px_new_2.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px_new_2.diminfo[2].strides = __pyx_pybuffernd_px_new_2.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px_new_2.diminfo[2].shape = __pyx_pybuffernd_px_new_2.rcbuffer->pybuffer.shape[2];
+    }
+  }
+  __pyx_t_13 = 0;
+  __pyx_v_px_new_2 = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "prange_saliency_mbd.pyx":185
+ * 	cdef np.ndarray[double,ndim=3] px_new
+ * 	cdef Py_ssize_t x
+ * 	for x in xrange(4):             # <<<<<<<<<<<<<<
+ * 		if x//2 == 0:
+ * 			px = px_1
+ */
+  for (__pyx_t_14 = 0; __pyx_t_14 < 4; __pyx_t_14+=1) {
+    __pyx_v_x = __pyx_t_14;
+
+    /* "prange_saliency_mbd.pyx":186
+ * 	cdef Py_ssize_t x
+ * 	for x in xrange(4):
+ * 		if x//2 == 0:             # <<<<<<<<<<<<<<
+ * 			px = px_1
+ * 			px_new = px_new_1
+ */
+    __pyx_t_15 = ((__Pyx_div_Py_ssize_t(__pyx_v_x, 2) == 0) != 0);
+    if (__pyx_t_15) {
+
+      /* "prange_saliency_mbd.pyx":187
+ * 	for x in xrange(4):
+ * 		if x//2 == 0:
+ * 			px = px_1             # <<<<<<<<<<<<<<
+ * 			px_new = px_new_1
+ * 		else:
+ */
+      {
+        __Pyx_BufFmt_StackElem __pyx_stack[1];
+        __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px.rcbuffer->pybuffer);
+        __pyx_t_5 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_v_px_1), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack);
+        if (unlikely(__pyx_t_5 < 0)) {
+          PyErr_Fetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px.rcbuffer->pybuffer, (PyObject*)__pyx_v_px, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack) == -1)) {
+            Py_XDECREF(__pyx_t_16); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_18);
+            __Pyx_RaiseBufferFallbackError();
+          } else {
+            PyErr_Restore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          }
+          __pyx_t_16 = __pyx_t_17 = __pyx_t_18 = 0;
+        }
+        __pyx_pybuffernd_px.diminfo[0].strides = __pyx_pybuffernd_px.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px.diminfo[0].shape = __pyx_pybuffernd_px.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px.diminfo[1].strides = __pyx_pybuffernd_px.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px.diminfo[1].shape = __pyx_pybuffernd_px.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px.diminfo[2].strides = __pyx_pybuffernd_px.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px.diminfo[2].shape = __pyx_pybuffernd_px.rcbuffer->pybuffer.shape[2]; __pyx_pybuffernd_px.diminfo[3].strides = __pyx_pybuffernd_px.rcbuffer->pybuffer.strides[3]; __pyx_pybuffernd_px.diminfo[3].shape = __pyx_pybuffernd_px.rcbuffer->pybuffer.shape[3];
+        if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 187, __pyx_L1_error)
+      }
+      __Pyx_INCREF(((PyObject *)__pyx_v_px_1));
+      __Pyx_XDECREF_SET(__pyx_v_px, ((PyArrayObject *)__pyx_v_px_1));
+
+      /* "prange_saliency_mbd.pyx":188
+ * 		if x//2 == 0:
+ * 			px = px_1
+ * 			px_new = px_new_1             # <<<<<<<<<<<<<<
+ * 		else:
+ * 			px = px_2
+ */
+      {
+        __Pyx_BufFmt_StackElem __pyx_stack[1];
+        __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_new.rcbuffer->pybuffer);
+        __pyx_t_5 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_new.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_v_px_new_1), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack);
+        if (unlikely(__pyx_t_5 < 0)) {
+          PyErr_Fetch(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
+          if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_new.rcbuffer->pybuffer, (PyObject*)__pyx_v_px_new, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
+            Py_XDECREF(__pyx_t_18); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_16);
+            __Pyx_RaiseBufferFallbackError();
+          } else {
+            PyErr_Restore(__pyx_t_18, __pyx_t_17, __pyx_t_16);
+          }
+          __pyx_t_18 = __pyx_t_17 = __pyx_t_16 = 0;
+        }
+        __pyx_pybuffernd_px_new.diminfo[0].strides = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px_new.diminfo[0].shape = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px_new.diminfo[1].strides = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px_new.diminfo[1].shape = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px_new.diminfo[2].strides = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px_new.diminfo[2].shape = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.shape[2];
+        if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 188, __pyx_L1_error)
+      }
+      __Pyx_INCREF(((PyObject *)__pyx_v_px_new_1));
+      __Pyx_XDECREF_SET(__pyx_v_px_new, ((PyArrayObject *)__pyx_v_px_new_1));
+
+      /* "prange_saliency_mbd.pyx":186
+ * 	cdef Py_ssize_t x
+ * 	for x in xrange(4):
+ * 		if x//2 == 0:             # <<<<<<<<<<<<<<
+ * 			px = px_1
+ * 			px_new = px_new_1
+ */
+      goto __pyx_L5;
+    }
+
+    /* "prange_saliency_mbd.pyx":190
+ * 			px_new = px_new_1
+ * 		else:
+ * 			px = px_2             # <<<<<<<<<<<<<<
+ * 			px_new = px_new_2
+ * 		px_mean[x] = np.mean(px[x%2],axis=(0,1))
+ */
+    /*else*/ {
+      {
+        __Pyx_BufFmt_StackElem __pyx_stack[1];
+        __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px.rcbuffer->pybuffer);
+        __pyx_t_5 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_v_px_2), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack);
+        if (unlikely(__pyx_t_5 < 0)) {
+          PyErr_Fetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
+          if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px.rcbuffer->pybuffer, (PyObject*)__pyx_v_px, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack) == -1)) {
+            Py_XDECREF(__pyx_t_16); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_18);
+            __Pyx_RaiseBufferFallbackError();
+          } else {
+            PyErr_Restore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
+          }
+          __pyx_t_16 = __pyx_t_17 = __pyx_t_18 = 0;
+        }
+        __pyx_pybuffernd_px.diminfo[0].strides = __pyx_pybuffernd_px.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px.diminfo[0].shape = __pyx_pybuffernd_px.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px.diminfo[1].strides = __pyx_pybuffernd_px.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px.diminfo[1].shape = __pyx_pybuffernd_px.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px.diminfo[2].strides = __pyx_pybuffernd_px.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px.diminfo[2].shape = __pyx_pybuffernd_px.rcbuffer->pybuffer.shape[2]; __pyx_pybuffernd_px.diminfo[3].strides = __pyx_pybuffernd_px.rcbuffer->pybuffer.strides[3]; __pyx_pybuffernd_px.diminfo[3].shape = __pyx_pybuffernd_px.rcbuffer->pybuffer.shape[3];
+        if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 190, __pyx_L1_error)
+      }
+      __Pyx_INCREF(((PyObject *)__pyx_v_px_2));
+      __Pyx_XDECREF_SET(__pyx_v_px, ((PyArrayObject *)__pyx_v_px_2));
+
+      /* "prange_saliency_mbd.pyx":191
+ * 		else:
+ * 			px = px_2
+ * 			px_new = px_new_2             # <<<<<<<<<<<<<<
+ * 		px_mean[x] = np.mean(px[x%2],axis=(0,1))
+ * 		px_new[x%2] = px[x%2].reshape(((n_cols if x//2 == 0 else n_rows)*border_thickness,3))
+ */
+      {
+        __Pyx_BufFmt_StackElem __pyx_stack[1];
+        __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_new.rcbuffer->pybuffer);
+        __pyx_t_5 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_new.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_v_px_new_2), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack);
+        if (unlikely(__pyx_t_5 < 0)) {
+          PyErr_Fetch(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
+          if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_new.rcbuffer->pybuffer, (PyObject*)__pyx_v_px_new, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
+            Py_XDECREF(__pyx_t_18); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_16);
+            __Pyx_RaiseBufferFallbackError();
+          } else {
+            PyErr_Restore(__pyx_t_18, __pyx_t_17, __pyx_t_16);
+          }
+          __pyx_t_18 = __pyx_t_17 = __pyx_t_16 = 0;
+        }
+        __pyx_pybuffernd_px_new.diminfo[0].strides = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px_new.diminfo[0].shape = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px_new.diminfo[1].strides = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px_new.diminfo[1].shape = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px_new.diminfo[2].strides = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px_new.diminfo[2].shape = __pyx_pybuffernd_px_new.rcbuffer->pybuffer.shape[2];
+        if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 191, __pyx_L1_error)
+      }
+      __Pyx_INCREF(((PyObject *)__pyx_v_px_new_2));
+      __Pyx_XDECREF_SET(__pyx_v_px_new, ((PyArrayObject *)__pyx_v_px_new_2));
+    }
+    __pyx_L5:;
+
+    /* "prange_saliency_mbd.pyx":192
+ * 			px = px_2
+ * 			px_new = px_new_2
+ * 		px_mean[x] = np.mean(px[x%2],axis=(0,1))             # <<<<<<<<<<<<<<
+ * 		px_new[x%2] = px[x%2].reshape(((n_cols if x//2 == 0 else n_rows)*border_thickness,3))
+ * 		cov[x] =  np.linalg.inv(np.cov(px_new[x%2].T))
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_19 = __Pyx_mod_Py_ssize_t(__pyx_v_x, 2);
+    __pyx_t_6 = __Pyx_GetItemInt(((PyObject *)__pyx_v_px), __pyx_t_19, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_axis, __pyx_tuple__6) < 0) __PYX_ERR(0, 192, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_px_mean), __pyx_v_x, __pyx_t_2, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0) < 0)) __PYX_ERR(0, 192, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "prange_saliency_mbd.pyx":193
+ * 			px_new = px_new_2
+ * 		px_mean[x] = np.mean(px[x%2],axis=(0,1))
+ * 		px_new[x%2] = px[x%2].reshape(((n_cols if x//2 == 0 else n_rows)*border_thickness,3))             # <<<<<<<<<<<<<<
+ * 		cov[x] =  np.linalg.inv(np.cov(px_new[x%2].T))
+ * 
+ */
+    __pyx_t_19 = __Pyx_mod_Py_ssize_t(__pyx_v_x, 2);
+    __pyx_t_6 = __Pyx_GetItemInt(((PyObject *)__pyx_v_px), __pyx_t_19, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 193, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_reshape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (((__Pyx_div_Py_ssize_t(__pyx_v_x, 2) == 0) != 0)) {
+      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_cols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_6 = __pyx_t_1;
+      __pyx_t_1 = 0;
+    } else {
+      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_rows); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_6 = __pyx_t_1;
+      __pyx_t_1 = 0;
+    }
+    __pyx_t_1 = PyNumber_Multiply(__pyx_t_6, __pyx_v_border_thickness); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 193, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
+    __Pyx_INCREF(__pyx_int_3);
+    __Pyx_GIVEREF(__pyx_int_3);
+    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_int_3);
+    __pyx_t_1 = 0;
+    __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+      }
+    }
+    __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_19 = __Pyx_mod_Py_ssize_t(__pyx_v_x, 2);
+    if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_px_new), __pyx_t_19, __pyx_t_2, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0) < 0)) __PYX_ERR(0, 193, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "prange_saliency_mbd.pyx":194
+ * 		px_mean[x] = np.mean(px[x%2],axis=(0,1))
+ * 		px_new[x%2] = px[x%2].reshape(((n_cols if x//2 == 0 else n_rows)*border_thickness,3))
+ * 		cov[x] =  np.linalg.inv(np.cov(px_new[x%2].T))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_linalg); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_inv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cov); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_19 = __Pyx_mod_Py_ssize_t(__pyx_v_x, 2);
+    __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_px_new), __pyx_t_19, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_T); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_6 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_t_20) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_20);
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+      }
+    }
+    __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_cov), __pyx_v_x, __pyx_t_2, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0) < 0)) __PYX_ERR(0, 194, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+
+  /* "prange_saliency_mbd.pyx":197
+ * 
+ * 
+ * 	cdef np.ndarray[double,ndim=3] u = np.empty((4,img_lab.shape[0],img_lab.shape[1]))             # <<<<<<<<<<<<<<
+ * 
+ * 	cdef np.ndarray[double,ndim=2] img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_20 = PyTuple_New(3); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_int_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_20, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_20, 2, __pyx_t_4);
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_20) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_20);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 197, __pyx_L1_error)
+  __pyx_t_21 = ((PyArrayObject *)__pyx_t_2);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_u.rcbuffer->pybuffer, (PyObject*)__pyx_t_21, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
+      __pyx_v_u = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_u.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 197, __pyx_L1_error)
+    } else {__pyx_pybuffernd_u.diminfo[0].strides = __pyx_pybuffernd_u.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_u.diminfo[0].shape = __pyx_pybuffernd_u.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_u.diminfo[1].strides = __pyx_pybuffernd_u.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_u.diminfo[1].shape = __pyx_pybuffernd_u.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_u.diminfo[2].strides = __pyx_pybuffernd_u.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_u.diminfo[2].shape = __pyx_pybuffernd_u.rcbuffer->pybuffer.shape[2];
+    }
+  }
+  __pyx_t_21 = 0;
+  __pyx_v_u = ((PyArrayObject *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "prange_saliency_mbd.pyx":199
+ * 	cdef np.ndarray[double,ndim=3] u = np.empty((4,img_lab.shape[0],img_lab.shape[1]))
+ * 
+ * 	cdef np.ndarray[double,ndim=2] img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)             # <<<<<<<<<<<<<<
+ * 	cdef np.ndarray[double,ndim=3] px_mean_2 = np.empty((4,1,3))
+ * 	for x in xrange(4):
+ */
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_img_lab), __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_20 = __Pyx_PyInt_From_Py_intptr_t(((__pyx_v_img_lab->dimensions[0]) * (__pyx_v_img_lab->dimensions[1]))); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_4 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_6)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_20, __pyx_int_3};
+    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_20, __pyx_int_3};
+    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_3 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 199, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__pyx_t_4) {
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_20);
+    PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_5, __pyx_t_20);
+    __Pyx_INCREF(__pyx_int_3);
+    __Pyx_GIVEREF(__pyx_int_3);
+    PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_5, __pyx_int_3);
+    __pyx_t_20 = 0;
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 199, __pyx_L1_error)
+  __pyx_t_22 = ((PyArrayObject *)__pyx_t_2);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_img_lab_unrolled.rcbuffer->pybuffer, (PyObject*)__pyx_t_22, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_img_lab_unrolled = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_img_lab_unrolled.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 199, __pyx_L1_error)
+    } else {__pyx_pybuffernd_img_lab_unrolled.diminfo[0].strides = __pyx_pybuffernd_img_lab_unrolled.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_img_lab_unrolled.diminfo[0].shape = __pyx_pybuffernd_img_lab_unrolled.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_img_lab_unrolled.diminfo[1].strides = __pyx_pybuffernd_img_lab_unrolled.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_img_lab_unrolled.diminfo[1].shape = __pyx_pybuffernd_img_lab_unrolled.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_22 = 0;
+  __pyx_v_img_lab_unrolled = ((PyArrayObject *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "prange_saliency_mbd.pyx":200
+ * 
+ * 	cdef np.ndarray[double,ndim=2] img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)
+ * 	cdef np.ndarray[double,ndim=3] px_mean_2 = np.empty((4,1,3))             # <<<<<<<<<<<<<<
+ * 	for x in xrange(4):
+ * 		px_mean_2[x,0] = px_mean[x]
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_tuple__9) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_tuple__9);
+  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 200, __pyx_L1_error)
+  __pyx_t_23 = ((PyArrayObject *)__pyx_t_2);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer, (PyObject*)__pyx_t_23, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
+      __pyx_v_px_mean_2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(0, 200, __pyx_L1_error)
+    } else {__pyx_pybuffernd_px_mean_2.diminfo[0].strides = __pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_px_mean_2.diminfo[0].shape = __pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_px_mean_2.diminfo[1].strides = __pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_px_mean_2.diminfo[1].shape = __pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_px_mean_2.diminfo[2].strides = __pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_px_mean_2.diminfo[2].shape = __pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer.shape[2];
+    }
+  }
+  __pyx_t_23 = 0;
+  __pyx_v_px_mean_2 = ((PyArrayObject *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "prange_saliency_mbd.pyx":201
+ * 	cdef np.ndarray[double,ndim=2] img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)
+ * 	cdef np.ndarray[double,ndim=3] px_mean_2 = np.empty((4,1,3))
+ * 	for x in xrange(4):             # <<<<<<<<<<<<<<
+ * 		px_mean_2[x,0] = px_mean[x]
+ * 		u[x] = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_2[x],'mahalanobis', VI=cov[x]).reshape((img_lab.shape[0],img_lab.shape[1]))
+ */
+  for (__pyx_t_14 = 0; __pyx_t_14 < 4; __pyx_t_14+=1) {
+    __pyx_v_x = __pyx_t_14;
+
+    /* "prange_saliency_mbd.pyx":202
+ * 	cdef np.ndarray[double,ndim=3] px_mean_2 = np.empty((4,1,3))
+ * 	for x in xrange(4):
+ * 		px_mean_2[x,0] = px_mean[x]             # <<<<<<<<<<<<<<
+ * 		u[x] = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_2[x],'mahalanobis', VI=cov[x]).reshape((img_lab.shape[0],img_lab.shape[1]))
+ * 		u[x] = u[x]/np.max(u[x])
+ */
+    __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_px_mean), __pyx_v_x, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
+    __Pyx_INCREF(__pyx_int_0);
+    __Pyx_GIVEREF(__pyx_int_0);
+    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_int_0);
+    __pyx_t_3 = 0;
+    if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_px_mean_2), __pyx_t_6, __pyx_t_2) < 0)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "prange_saliency_mbd.pyx":203
+ * 	for x in xrange(4):
+ * 		px_mean_2[x,0] = px_mean[x]
+ * 		u[x] = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_2[x],'mahalanobis', VI=cov[x]).reshape((img_lab.shape[0],img_lab.shape[1]))             # <<<<<<<<<<<<<<
+ * 		u[x] = u[x]/np.max(u[x])
+ * 
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_scipy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_spatial); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_distance); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_cdist); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_6 = __Pyx_GetItemInt(((PyObject *)__pyx_v_px_mean_2), __pyx_v_x, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_20 = PyTuple_New(3); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_INCREF(((PyObject *)__pyx_v_img_lab_unrolled));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_img_lab_unrolled));
+    PyTuple_SET_ITEM(__pyx_t_20, 0, ((PyObject *)__pyx_v_img_lab_unrolled));
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_20, 1, __pyx_t_6);
+    __Pyx_INCREF(__pyx_n_s_mahalanobis);
+    __Pyx_GIVEREF(__pyx_n_s_mahalanobis);
+    PyTuple_SET_ITEM(__pyx_t_20, 2, __pyx_n_s_mahalanobis);
+    __pyx_t_6 = 0;
+    __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = __Pyx_GetItemInt(((PyObject *)__pyx_v_cov), __pyx_v_x, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_VI, __pyx_t_4) < 0) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_20, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_20 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_img_lab->dimensions[1])); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_20);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_20);
+    __pyx_t_4 = 0;
+    __pyx_t_20 = 0;
+    __pyx_t_20 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_20)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_20);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    __pyx_t_2 = (__pyx_t_20) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_20, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_u), __pyx_v_x, __pyx_t_2, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0) < 0)) __PYX_ERR(0, 203, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "prange_saliency_mbd.pyx":204
+ * 		px_mean_2[x,0] = px_mean[x]
+ * 		u[x] = scipy.spatial.distance.cdist(img_lab_unrolled,px_mean_2[x],'mahalanobis', VI=cov[x]).reshape((img_lab.shape[0],img_lab.shape[1]))
+ * 		u[x] = u[x]/np.max(u[x])             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_u), __pyx_v_x, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_max); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_u), __pyx_v_x, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_20))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_20);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_20);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_20, function);
+      }
+    }
+    __pyx_t_6 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_20, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_20, __pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+    __pyx_t_20 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_u), __pyx_v_x, __pyx_t_20, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0) < 0)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  }
+
+  /* "prange_saliency_mbd.pyx":207
+ * 
+ * 
+ * 	u_max = np.maximum(np.maximum(u[0],u[1]),np.maximum(u[2],u[3]))             # <<<<<<<<<<<<<<
+ * 
+ * 	u_final = np.sum (u,axis = 0) - u_max
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_maximum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_maximum); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_u), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_u), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_24 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_24 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_24)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_24);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_24, __pyx_t_3, __pyx_t_1};
+    __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_24, __pyx_t_3, __pyx_t_1};
+    __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_25 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_25);
+    if (__pyx_t_24) {
+      __Pyx_GIVEREF(__pyx_t_24); PyTuple_SET_ITEM(__pyx_t_25, 0, __pyx_t_24); __pyx_t_24 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_25, 0+__pyx_t_5, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_25, 1+__pyx_t_5, __pyx_t_1);
+    __pyx_t_3 = 0;
+    __pyx_t_1 = 0;
+    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_25, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_n_s_np); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_25);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_25, __pyx_n_s_maximum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+  __pyx_t_25 = __Pyx_GetItemInt(((PyObject *)__pyx_v_u), 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_25);
+  __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_u), 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_24 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_24 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_24)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_24);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_1)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_24, __pyx_t_25, __pyx_t_3};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_24, __pyx_t_25, __pyx_t_3};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_26 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_26);
+    if (__pyx_t_24) {
+      __Pyx_GIVEREF(__pyx_t_24); PyTuple_SET_ITEM(__pyx_t_26, 0, __pyx_t_24); __pyx_t_24 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_25);
+    PyTuple_SET_ITEM(__pyx_t_26, 0+__pyx_t_5, __pyx_t_25);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_26, 1+__pyx_t_5, __pyx_t_3);
+    __pyx_t_25 = 0;
+    __pyx_t_3 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_26, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_6, __pyx_t_4};
+    __pyx_t_20 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_6, __pyx_t_4};
+    __pyx_t_20 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_26 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_26);
+    if (__pyx_t_1) {
+      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_26, 0, __pyx_t_1); __pyx_t_1 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_26, 0+__pyx_t_5, __pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_26, 1+__pyx_t_5, __pyx_t_4);
+    __pyx_t_6 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_26, NULL); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_u_max = __pyx_t_20;
+  __pyx_t_20 = 0;
+
+  /* "prange_saliency_mbd.pyx":209
+ * 	u_max = np.maximum(np.maximum(u[0],u[1]),np.maximum(u[2],u[3]))
+ * 
+ * 	u_final = np.sum (u,axis = 0) - u_max             # <<<<<<<<<<<<<<
+ * 
+ * 	u_max_final = np.max(u_final)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_n_s_np); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_n_s_sum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = PyTuple_New(1); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_INCREF(((PyObject *)__pyx_v_u));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_u));
+  PyTuple_SET_ITEM(__pyx_t_20, 0, ((PyObject *)__pyx_v_u));
+  __pyx_t_26 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  if (PyDict_SetItem(__pyx_t_26, __pyx_n_s_axis, __pyx_int_0) < 0) __PYX_ERR(0, 209, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_20, __pyx_t_26); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  __pyx_t_26 = PyNumber_Subtract(__pyx_t_4, __pyx_v_u_max); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_u_final = __pyx_t_26;
+  __pyx_t_26 = 0;
+
+  /* "prange_saliency_mbd.pyx":211
+ * 	u_final = np.sum (u,axis = 0) - u_max
+ * 
+ * 	u_max_final = np.max(u_final)             # <<<<<<<<<<<<<<
+ * 	sal_max = np.max(sal)
+ * 	sal = sal / sal_max + u_final / u_max_final
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_20))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_20);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_20);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_20, function);
+    }
+  }
+  __pyx_t_26 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_20, __pyx_t_4, __pyx_v_u_final) : __Pyx_PyObject_CallOneArg(__pyx_t_20, __pyx_v_u_final);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_v_u_max_final = __pyx_t_26;
+  __pyx_t_26 = 0;
+
+  /* "prange_saliency_mbd.pyx":212
+ * 
+ * 	u_max_final = np.max(u_final)
+ * 	sal_max = np.max(sal)             # <<<<<<<<<<<<<<
+ * 	sal = sal / sal_max + u_final / u_max_final
+ * 
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_n_s_np); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_20)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_20);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_26 = (__pyx_t_20) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_20, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_sal_max = __pyx_t_26;
+  __pyx_t_26 = 0;
+
+  /* "prange_saliency_mbd.pyx":213
+ * 	u_max_final = np.max(u_final)
+ * 	sal_max = np.max(sal)
+ * 	sal = sal / sal_max + u_final / u_max_final             # <<<<<<<<<<<<<<
+ * 
+ * 	#postprocessing
+ */
+  __pyx_t_26 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_v_sal_max); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_u_final, __pyx_v_u_max_final); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_20 = PyNumber_Add(__pyx_t_26, __pyx_t_4); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_20);
+  __pyx_t_20 = 0;
+
+  /* "prange_saliency_mbd.pyx":218
+ * 
+ * 	# apply centredness map
+ * 	sal = sal / np.max(sal)             # <<<<<<<<<<<<<<
+ * 	s = np.mean(sal)
+ * 	cdef double alpha = 50.0
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_26 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_max); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_26))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_26);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_26);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_26, function);
+    }
+  }
+  __pyx_t_20 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_26, __pyx_t_4, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_26, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  __pyx_t_26 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_20); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_26);
+  __pyx_t_26 = 0;
+
+  /* "prange_saliency_mbd.pyx":219
+ * 	# apply centredness map
+ * 	sal = sal / np.max(sal)
+ * 	s = np.mean(sal)             # <<<<<<<<<<<<<<
+ * 	cdef double alpha = 50.0
+ * 	cdef double delta = alpha * sqrt(s)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_n_s_np); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_20)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_20);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_26 = (__pyx_t_20) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_20, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_s = __pyx_t_26;
+  __pyx_t_26 = 0;
+
+  /* "prange_saliency_mbd.pyx":220
+ * 	sal = sal / np.max(sal)
+ * 	s = np.mean(sal)
+ * 	cdef double alpha = 50.0             # <<<<<<<<<<<<<<
+ * 	cdef double delta = alpha * sqrt(s)
+ * 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))
+ */
+  __pyx_v_alpha = 50.0;
+
+  /* "prange_saliency_mbd.pyx":221
+ * 	s = np.mean(sal)
+ * 	cdef double alpha = 50.0
+ * 	cdef double delta = alpha * sqrt(s)             # <<<<<<<<<<<<<<
+ * 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))
+ * 	cdef int w = sal.shape[0]
+ */
+  __pyx_t_27 = __pyx_PyFloat_AsDouble(__pyx_v_s); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 221, __pyx_L1_error)
+  __pyx_v_delta = (__pyx_v_alpha * sqrt(__pyx_t_27));
+
+  /* "prange_saliency_mbd.pyx":222
+ * 	cdef double alpha = 50.0
+ * 	cdef double delta = alpha * sqrt(s)
+ * 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))             # <<<<<<<<<<<<<<
+ * 	cdef int w = sal.shape[0]
+ * 	cdef int h = sal.shape[1]
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_meshgrid); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_arange); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_2, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_arange); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_6 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_20))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_20);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_20);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_20, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_20)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_4, __pyx_t_6};
+    __pyx_t_26 = __Pyx_PyFunction_FastCall(__pyx_t_20, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_26);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_20)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_4, __pyx_t_6};
+    __pyx_t_26 = __Pyx_PyCFunction_FastCall(__pyx_t_20, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_26);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_3 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__pyx_t_2) {
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_5, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_5, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_6 = 0;
+    __pyx_t_26 = __Pyx_PyObject_Call(__pyx_t_20, __pyx_t_3, NULL); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_26);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_26))) || (PyList_CheckExact(__pyx_t_26))) {
+    PyObject* sequence = __pyx_t_26;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 222, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_20 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
+    } else {
+      __pyx_t_20 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
+    }
+    __Pyx_INCREF(__pyx_t_20);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_20 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_6 = PyObject_GetIter(__pyx_t_26); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+    __pyx_t_28 = Py_TYPE(__pyx_t_6)->tp_iternext;
+    index = 0; __pyx_t_20 = __pyx_t_28(__pyx_t_6); if (unlikely(!__pyx_t_20)) goto __pyx_L8_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_20);
+    index = 1; __pyx_t_3 = __pyx_t_28(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L8_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_28(__pyx_t_6), 2) < 0) __PYX_ERR(0, 222, __pyx_L1_error)
+    __pyx_t_28 = NULL;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    goto __pyx_L9_unpacking_done;
+    __pyx_L8_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_28 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 222, __pyx_L1_error)
+    __pyx_L9_unpacking_done:;
+  }
+  __pyx_v_xv = __pyx_t_20;
+  __pyx_t_20 = 0;
+  __pyx_v_yv = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "prange_saliency_mbd.pyx":223
+ * 	cdef double delta = alpha * sqrt(s)
+ * 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))
+ * 	cdef int w = sal.shape[0]             # <<<<<<<<<<<<<<
+ * 	cdef int h = sal.shape[1]
+ * 	cdef double w2 = w/2.0
+ */
+  __pyx_t_26 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_26, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 223, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_w = __pyx_t_5;
+
+  /* "prange_saliency_mbd.pyx":224
+ * 	xv,yv = np.meshgrid(np.arange(sal.shape[1]),np.arange(sal.shape[0]))
+ * 	cdef int w = sal.shape[0]
+ * 	cdef int h = sal.shape[1]             # <<<<<<<<<<<<<<
+ * 	cdef double w2 = w/2.0
+ * 	cdef double h2 = h/2.0
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sal, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_26 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_26); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  __pyx_v_h = __pyx_t_5;
+
+  /* "prange_saliency_mbd.pyx":225
+ * 	cdef int w = sal.shape[0]
+ * 	cdef int h = sal.shape[1]
+ * 	cdef double w2 = w/2.0             # <<<<<<<<<<<<<<
+ * 	cdef double h2 = h/2.0
+ * 
+ */
+  __pyx_v_w2 = (__pyx_v_w / 2.0);
+
+  /* "prange_saliency_mbd.pyx":226
+ * 	cdef int h = sal.shape[1]
+ * 	cdef double w2 = w/2.0
+ * 	cdef double h2 = h/2.0             # <<<<<<<<<<<<<<
+ * 
+ * 	C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2))
+ */
+  __pyx_v_h2 = (__pyx_v_h / 2.0);
+
+  /* "prange_saliency_mbd.pyx":228
+ * 	cdef double h2 = h/2.0
+ * 
+ * 	C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2))             # <<<<<<<<<<<<<<
+ * 
+ * 	sal = sal * C
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = PyNumber_Subtract(__pyx_v_xv, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_2, __pyx_int_2};
+    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_2, __pyx_int_2};
+    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_1 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (__pyx_t_6) {
+      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); __pyx_t_6 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_5, __pyx_t_2);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_5, __pyx_int_2);
+    __pyx_t_2 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = PyNumber_Subtract(__pyx_v_yv, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_6, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_t_6, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_25 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_25);
+    if (__pyx_t_1) {
+      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_25, 0, __pyx_t_1); __pyx_t_1 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_25, 0+__pyx_t_5, __pyx_t_6);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_25, 1+__pyx_t_5, __pyx_int_2);
+    __pyx_t_6 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_25, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_20))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_20);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_20);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_20, function);
+    }
+  }
+  __pyx_t_26 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_20, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_20, __pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_w2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2};
+    __pyx_t_20 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_2, __pyx_int_2};
+    __pyx_t_20 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_25 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_25);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_25, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_25, 0+__pyx_t_5, __pyx_t_2);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_25, 1+__pyx_t_5, __pyx_int_2);
+    __pyx_t_2 = 0;
+    __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_25, NULL); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_25, __pyx_n_s_np); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_25);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_25, __pyx_n_s_power); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+  __pyx_t_25 = PyFloat_FromDouble(__pyx_v_h2); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_25);
+  __pyx_t_3 = NULL;
+  __pyx_t_5 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_5 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_25, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_25, __pyx_int_2};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_25); __pyx_t_25 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (__pyx_t_3) {
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_25);
+    PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_t_25);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_int_2);
+    __pyx_t_25 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_t_20, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_27 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyFloat_FromDouble(sqrt(__pyx_t_27)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_26, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyInt_SubtractCObj(__pyx_int_1, __pyx_t_4, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_C = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "prange_saliency_mbd.pyx":230
+ * 	C = 1 - np.sqrt(np.power(xv - h2,2) + np.power(yv - w2,2)) / sqrt(np.power(w2,2) + np.power(h2,2))
+ * 
+ * 	sal = sal * C             # <<<<<<<<<<<<<<
+ * 
+ * 	fv = np.vectorize(f)
+ */
+  __pyx_t_2 = PyNumber_Multiply(__pyx_v_sal, __pyx_v_C); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "prange_saliency_mbd.pyx":232
+ * 	sal = sal * C
+ * 
+ * 	fv = np.vectorize(f)             # <<<<<<<<<<<<<<
+ * 
+ * 	sal = sal / np.max(sal)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_26 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_vectorize); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CFunc_object____object___to_py(__pyx_f_19prange_saliency_mbd_f); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_20 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_26))) {
+    __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_26);
+    if (likely(__pyx_t_20)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_26);
+      __Pyx_INCREF(__pyx_t_20);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_26, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_20) ? __Pyx_PyObject_Call2Args(__pyx_t_26, __pyx_t_20, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_26, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  __pyx_v_fv = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "prange_saliency_mbd.pyx":234
+ * 	fv = np.vectorize(f)
+ * 
+ * 	sal = sal / np.max(sal)             # <<<<<<<<<<<<<<
+ * 
+ * 	sal = fv(sal)
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_26, __pyx_n_s_np); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_26);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_26, __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
+  __pyx_t_26 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_26 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_26)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_26);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_26) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_26, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_sal, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "prange_saliency_mbd.pyx":236
+ * 	sal = sal / np.max(sal)
+ * 
+ * 	sal = fv(sal)             # <<<<<<<<<<<<<<
+ * 
+ * 	return sal* 255.0
+ */
+  __Pyx_INCREF(__pyx_v_fv);
+  __pyx_t_2 = __pyx_v_fv; __pyx_t_26 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_26 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_26)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_26);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_26) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_26, __pyx_v_sal) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_sal);
+  __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF_SET(__pyx_v_sal, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "prange_saliency_mbd.pyx":238
+ * 	sal = fv(sal)
+ * 
+ * 	return sal* 255.0             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyNumber_Multiply(__pyx_v_sal, __pyx_float_255_0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "prange_saliency_mbd.pyx":151
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef get_saliency_mbd(np.ndarray img,method='b', res = 2):             # <<<<<<<<<<<<<<
+ * 	# Saliency map calculation based on: Minimum Barrier Salient Object Detection at 80 FPS
+ * 	img_mean = np.mean(img,axis=(2))
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_20);
+  __Pyx_XDECREF(__pyx_t_24);
+  __Pyx_XDECREF(__pyx_t_25);
+  __Pyx_XDECREF(__pyx_t_26);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_cov.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img_lab.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img_lab_unrolled.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_1.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_2.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_mean.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_new.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_new_1.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_new_2.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_u.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("prange_saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_cov.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img_lab.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_img_lab_unrolled.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_1.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_2.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_mean.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_mean_2.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_new.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_new_1.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_px_new_2.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_u.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF(__pyx_v_img_mean);
+  __Pyx_XDECREF(__pyx_v_sal);
+  __Pyx_XDECREF(__pyx_v_border_thickness);
+  __Pyx_XDECREF((PyObject *)__pyx_v_img_lab);
+  __Pyx_XDECREF((PyObject *)__pyx_v_px_1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_px_2);
+  __Pyx_XDECREF((PyObject *)__pyx_v_px_mean);
+  __Pyx_XDECREF((PyObject *)__pyx_v_cov);
+  __Pyx_XDECREF((PyObject *)__pyx_v_px_new_1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_px_new_2);
+  __Pyx_XDECREF((PyObject *)__pyx_v_px);
+  __Pyx_XDECREF((PyObject *)__pyx_v_px_new);
+  __Pyx_XDECREF((PyObject *)__pyx_v_u);
+  __Pyx_XDECREF((PyObject *)__pyx_v_img_lab_unrolled);
+  __Pyx_XDECREF((PyObject *)__pyx_v_px_mean_2);
+  __Pyx_XDECREF(__pyx_v_u_max);
+  __Pyx_XDECREF(__pyx_v_u_final);
+  __Pyx_XDECREF(__pyx_v_u_max_final);
+  __Pyx_XDECREF(__pyx_v_sal_max);
+  __Pyx_XDECREF(__pyx_v_s);
+  __Pyx_XDECREF(__pyx_v_xv);
+  __Pyx_XDECREF(__pyx_v_yv);
+  __Pyx_XDECREF(__pyx_v_C);
+  __Pyx_XDECREF(__pyx_v_fv);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_19prange_saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyObject *__pyx_pw_19prange_saliency_mbd_1get_saliency_mbd(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_img = 0;
+  PyObject *__pyx_v_method = 0;
+  PyObject *__pyx_v_res = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_saliency_mbd (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_img,&__pyx_n_s_method,&__pyx_n_s_res,0};
+    PyObject* values[3] = {0,0,0};
+    values[1] = ((PyObject *)__pyx_n_s_b);
+    values[2] = ((PyObject *)__pyx_int_2);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_img)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method);
+          if (value) { values[1] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_res);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_saliency_mbd") < 0)) __PYX_ERR(0, 151, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_img = ((PyArrayObject *)values[0]);
+    __pyx_v_method = values[1];
+    __pyx_v_res = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_saliency_mbd", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 151, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("prange_saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_img), __pyx_ptype_5numpy_ndarray, 1, "img", 0))) __PYX_ERR(0, 151, __pyx_L1_error)
+  __pyx_r = __pyx_pf_19prange_saliency_mbd_get_saliency_mbd(__pyx_self, __pyx_v_img, __pyx_v_method, __pyx_v_res);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_19prange_saliency_mbd_get_saliency_mbd(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_img, PyObject *__pyx_v_method, PyObject *__pyx_v_res) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  struct __pyx_opt_args_19prange_saliency_mbd_get_saliency_mbd __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_saliency_mbd", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2.__pyx_n = 2;
+  __pyx_t_2.method = __pyx_v_method;
+  __pyx_t_2.res = __pyx_v_res;
+  __pyx_t_1 = __pyx_f_19prange_saliency_mbd_get_saliency_mbd(__pyx_v_img, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("prange_saliency_mbd.get_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fulfill the PEP.
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_v_i;
+  int __pyx_v_ndim;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  int __pyx_v_t;
+  char *__pyx_v_f;
+  PyArray_Descr *__pyx_v_descr = 0;
+  int __pyx_v_offset;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  PyArray_Descr *__pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  char *__pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  if (__pyx_v_info == NULL) {
+    PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
+    return -1;
+  }
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(__pyx_v_info->obj);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265
+ * 
+ *             cdef int i, ndim
+ *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *             cdef bint little_endian = ((&endian_detector)[0] != 0)
+ * 
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266
+ *             cdef int i, ndim
+ *             cdef int endian_detector = 1
+ *             cdef bint little_endian = ((&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ * 
+ *             ndim = PyArray_NDIM(self)
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268
+ *             cdef bint little_endian = ((&endian_detector)[0] != 0)
+ * 
+ *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ */
+  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  if (unlikely(__pyx_t_1)) {
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(1, 272, __pyx_L1_error)
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L7_bool_binop_done;
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L7_bool_binop_done:;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  if (unlikely(__pyx_t_1)) {
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(1, 276, __pyx_L1_error)
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
+ *             info.ndim = ndim
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279
+ * 
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim             # <<<<<<<<<<<<<<
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 # Allocate new buffer for strides and shape info.
+ */
+  __pyx_v_info->ndim = __pyx_v_ndim;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim)             # <<<<<<<<<<<<<<
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ */
+    __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim))));
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim)
+ *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ */
+    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285
+ *                 info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim)
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):             # <<<<<<<<<<<<<<
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ */
+    __pyx_t_4 = __pyx_v_ndim;
+    __pyx_t_5 = __pyx_t_4;
+    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+      __pyx_v_i = __pyx_t_6;
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ */
+      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.strides = PyArray_STRIDES(self)
+ */
+      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
+    }
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+    goto __pyx_L9;
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ *                 info.strides = PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
+ *                 info.shape = PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ */
+  /*else*/ {
+    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *             else:
+ *                 info.strides = PyArray_STRIDES(self)
+ *                 info.shape = PyArray_DIMS(self)             # <<<<<<<<<<<<<<
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ */
+    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
+  }
+  __pyx_L9:;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ *                 info.strides = PyArray_STRIDES(self)
+ *                 info.shape = PyArray_DIMS(self)
+ *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ */
+  __pyx_v_info->suboffsets = NULL;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292
+ *                 info.shape = PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ * 
+ */
+  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int t
+ */
+  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296
+ * 
+ *             cdef int t
+ *             cdef char* f = NULL             # <<<<<<<<<<<<<<
+ *             cdef dtype descr = PyArray_DESCR(self)
+ *             cdef int offset
+ */
+  __pyx_v_f = NULL;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297
+ *             cdef int t
+ *             cdef char* f = NULL
+ *             cdef dtype descr = PyArray_DESCR(self)             # <<<<<<<<<<<<<<
+ *             cdef int offset
+ * 
+ */
+  __pyx_t_7 = PyArray_DESCR(__pyx_v_self);
+  __pyx_t_3 = ((PyObject *)__pyx_t_7);
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300
+ *             cdef int offset
+ * 
+ *             info.obj = self             # <<<<<<<<<<<<<<
+ * 
+ *             if not PyDataType_HASFIELDS(descr):
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  __Pyx_GOTREF(__pyx_v_info->obj);
+  __Pyx_DECREF(__pyx_v_info->obj);
+  __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302
+ *             info.obj = self
+ * 
+ *             if not PyDataType_HASFIELDS(descr):             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303
+ * 
+ *             if not PyDataType_HASFIELDS(descr):
+ *                 t = descr.type_num             # <<<<<<<<<<<<<<
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ */
+    __pyx_t_4 = __pyx_v_descr->type_num;
+    __pyx_v_t = __pyx_t_4;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304
+ *             if not PyDataType_HASFIELDS(descr):
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
+    if (!__pyx_t_2) {
+      goto __pyx_L15_next_or;
+    } else {
+    }
+    __pyx_t_2 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L14_bool_binop_done;
+    }
+    __pyx_L15_next_or:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L14_bool_binop_done;
+    }
+    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_1 = __pyx_t_2;
+    __pyx_L14_bool_binop_done:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304
+ *             if not PyDataType_HASFIELDS(descr):
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    if (unlikely(__pyx_t_1)) {
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 306, __pyx_L1_error)
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304
+ *             if not PyDataType_HASFIELDS(descr):
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ */
+    switch (__pyx_v_t) {
+      case NPY_BYTE:
+      __pyx_v_f = ((char *)"b");
+      break;
+      case NPY_UBYTE:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ */
+      __pyx_v_f = ((char *)"B");
+      break;
+      case NPY_SHORT:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ */
+      __pyx_v_f = ((char *)"h");
+      break;
+      case NPY_USHORT:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ */
+      __pyx_v_f = ((char *)"H");
+      break;
+      case NPY_INT:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ */
+      __pyx_v_f = ((char *)"i");
+      break;
+      case NPY_UINT:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ */
+      __pyx_v_f = ((char *)"I");
+      break;
+      case NPY_LONG:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ */
+      __pyx_v_f = ((char *)"l");
+      break;
+      case NPY_ULONG:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ */
+      __pyx_v_f = ((char *)"L");
+      break;
+      case NPY_LONGLONG:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ */
+      __pyx_v_f = ((char *)"q");
+      break;
+      case NPY_ULONGLONG:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ */
+      __pyx_v_f = ((char *)"Q");
+      break;
+      case NPY_FLOAT:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ */
+      __pyx_v_f = ((char *)"f");
+      break;
+      case NPY_DOUBLE:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ */
+      __pyx_v_f = ((char *)"d");
+      break;
+      case NPY_LONGDOUBLE:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ */
+      __pyx_v_f = ((char *)"g");
+      break;
+      case NPY_CFLOAT:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ */
+      __pyx_v_f = ((char *)"Zf");
+      break;
+      case NPY_CDOUBLE:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"
+ */
+      __pyx_v_f = ((char *)"Zd");
+      break;
+      case NPY_CLONGDOUBLE:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ */
+      __pyx_v_f = ((char *)"Zg");
+      break;
+      case NPY_OBJECT:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      __pyx_v_f = ((char *)"O");
+      break;
+      default:
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *                 info.format = f
+ *                 return
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 325, __pyx_L1_error)
+      break;
+    }
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f             # <<<<<<<<<<<<<<
+ *                 return
+ *             else:
+ */
+    __pyx_v_info->format = __pyx_v_f;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f
+ *                 return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.format = PyObject_Malloc(_buffer_format_string_len)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302
+ *             info.obj = self
+ * 
+ *             if not PyDataType_HASFIELDS(descr):             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329
+ *                 return
+ *             else:
+ *                 info.format = PyObject_Malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ */
+  /*else*/ {
+    __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF));
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330
+ *             else:
+ *                 info.format = PyObject_Malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ */
+    (__pyx_v_info->format[0]) = '^';
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331
+ *                 info.format = PyObject_Malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0             # <<<<<<<<<<<<<<
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ *                                       info.format + _buffer_format_string_len,
+ */
+    __pyx_v_offset = 0;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ */
+    __pyx_t_9 = __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_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error)
+    __pyx_v_f = __pyx_t_9;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ */
+    (__pyx_v_f[0]) = '\x00';
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fulfill the PEP.
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_info->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_info->obj == Py_None) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+  }
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 PyObject_Free(info.format)
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 PyObject_Free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):
+ *                 PyObject_Free(info.format)             # <<<<<<<<<<<<<<
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 PyObject_Free(info.strides)
+ */
+    PyObject_Free(__pyx_v_info->format);
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 PyObject_Free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340
+ *             if PyArray_HASFIELDS(self):
+ *                 PyObject_Free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 PyObject_Free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341
+ *                 PyObject_Free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 PyObject_Free(info.strides)             # <<<<<<<<<<<<<<
+ *                 # info.shape was stored after info.strides in the same block
+ * 
+ */
+    PyObject_Free(__pyx_v_info->strides);
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340
+ *             if PyArray_HASFIELDS(self):
+ *                 PyObject_Free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 PyObject_Free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 PyObject_Free(info.format)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, a)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ *     return PyArray_MultiIterNew(1, a)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 821, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, a)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *     return PyArray_MultiIterNew(1, a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, a, b)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ *     return PyArray_MultiIterNew(2, a, b)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 824, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *     return PyArray_MultiIterNew(1, a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, a, b)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826
+ *     return PyArray_MultiIterNew(2, a, b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, a, b,  c)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ *     return PyArray_MultiIterNew(3, a, b,  c)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 827, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":826
+ *     return PyArray_MultiIterNew(2, a, b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, a, b,  c)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829
+ *     return PyArray_MultiIterNew(3, a, b,  c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, a, b, c,  d)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ *     return PyArray_MultiIterNew(4, a, b, c,  d)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 830, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":829
+ *     return PyArray_MultiIterNew(3, a, b,  c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, a, b, c,  d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832
+ *     return PyArray_MultiIterNew(4, a, b, c,  d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline tuple PyDataType_SHAPE(dtype d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 833, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":832
+ *     return PyArray_MultiIterNew(4, a, b, c,  d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835
+ *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
+ * 
+ * cdef inline tuple PyDataType_SHAPE(dtype d):             # <<<<<<<<<<<<<<
+ *     if PyDataType_HASSUBARRAY(d):
+ *         return d.subarray.shape
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836
+ * 
+ * cdef inline tuple PyDataType_SHAPE(dtype d):
+ *     if PyDataType_HASSUBARRAY(d):             # <<<<<<<<<<<<<<
+ *         return d.subarray.shape
+ *     else:
+ */
+  __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837
+ * cdef inline tuple PyDataType_SHAPE(dtype d):
+ *     if PyDataType_HASSUBARRAY(d):
+ *         return d.subarray.shape             # <<<<<<<<<<<<<<
+ *     else:
+ *         return ()
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape));
+    __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape);
+    goto __pyx_L0;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836
+ * 
+ * cdef inline tuple PyDataType_SHAPE(dtype d):
+ *     if PyDataType_HASSUBARRAY(d):             # <<<<<<<<<<<<<<
+ *         return d.subarray.shape
+ *     else:
+ */
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":839
+ *         return d.subarray.shape
+ *     else:
+ *         return ()             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_empty_tuple);
+    __pyx_r = __pyx_empty_tuple;
+    goto __pyx_L0;
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":835
+ *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
+ * 
+ * cdef inline tuple PyDataType_SHAPE(dtype d):             # <<<<<<<<<<<<<<
+ *     if PyDataType_HASSUBARRAY(d):
+ *         return d.subarray.shape
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841
+ *         return ()
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
+  PyArray_Descr *__pyx_v_child = 0;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  PyObject *__pyx_v_fields = 0;
+  PyObject *__pyx_v_childname = NULL;
+  PyObject *__pyx_v_new_offset = NULL;
+  PyObject *__pyx_v_t = NULL;
+  char *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  long __pyx_t_8;
+  char *__pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_util_dtypestring", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":846
+ * 
+ *     cdef dtype child
+ *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *     cdef bint little_endian = ((&endian_detector)[0] != 0)
+ *     cdef tuple fields
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847
+ *     cdef dtype child
+ *     cdef int endian_detector = 1
+ *     cdef bint little_endian = ((&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ *     cdef tuple fields
+ * 
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  if (unlikely(__pyx_v_descr->names == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(1, 850, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 850, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 850, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851
+ * 
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
+ *         child, new_offset = fields
+ * 
+ */
+    if (unlikely(__pyx_v_descr->fields == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(1, 851, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 851, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
+    __pyx_t_3 = 0;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields             # <<<<<<<<<<<<<<
+ * 
+ *         if (end - f) - (new_offset - offset[0]) < 15:
+ */
+    if (likely(__pyx_v_fields != Py_None)) {
+      PyObject* sequence = __pyx_v_fields;
+      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(1, 852, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      #else
+      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 852, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      #endif
+    } else {
+      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 852, __pyx_L1_error)
+    }
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 852, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
+    __pyx_t_3 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - (new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 854, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 854, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 854, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
+    if (unlikely(__pyx_t_6)) {
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855
+ * 
+ *         if (end - f) - (new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 855, __pyx_L1_error)
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":854
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - (new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    }
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
+    if (!__pyx_t_7) {
+      goto __pyx_L8_next_or;
+    } else {
+    }
+    __pyx_t_7 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_L8_next_or:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *             raise ValueError(u"Non-native byte order not supported")
+ *             # One could encode it in the format string and have Cython
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
+    if (__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_6 = __pyx_t_7;
+    __pyx_L7_bool_binop_done:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    if (unlikely(__pyx_t_6)) {
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 859, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(1, 859, __pyx_L1_error)
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":857
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":869
+ * 
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ */
+    while (1) {
+      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 869, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 869, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 869, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (!__pyx_t_6) break;
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
+ *             f += 1
+ *             offset[0] += 1
+ */
+      (__pyx_v_f[0]) = 0x78;
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1             # <<<<<<<<<<<<<<
+ *             offset[0] += 1
+ * 
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ *             offset[0] += 1             # <<<<<<<<<<<<<<
+ * 
+ *         offset[0] += child.itemsize
+ */
+      __pyx_t_8 = 0;
+      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
+    }
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":874
+ *             offset[0] += 1
+ * 
+ *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ */
+    __pyx_t_8 = 0;
+    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num             # <<<<<<<<<<<<<<
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 877, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
+      if (unlikely(__pyx_t_6)) {
+
+        /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 879, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(1, 879, __pyx_L1_error)
+
+        /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":882
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 882, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 882, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 882, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 98;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x68;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 72;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x69;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 73;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x6C;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 76;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x71;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 81;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x64;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x67;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x66;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x64;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x67;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (likely(__pyx_t_6)) {
+        (__pyx_v_f[0]) = 79;
+        goto __pyx_L15;
+      }
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":900
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *             f += 1
+ *         else:
+ */
+      /*else*/ {
+        __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 900, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 900, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(1, 900, __pyx_L1_error)
+      }
+      __pyx_L15:;
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *             f += 1             # <<<<<<<<<<<<<<
+ *         else:
+ *             # Cython ignores struct boundary information ("T{...}"),
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":876
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+      goto __pyx_L13;
+    }
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":905
+ *             # Cython ignores struct boundary information ("T{...}"),
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
+ *     return f
+ * 
+ */
+    /*else*/ {
+      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 905, __pyx_L1_error)
+      __pyx_v_f = __pyx_t_9;
+    }
+    __pyx_L13:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":850
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)
+ *     return f             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_f;
+  goto __pyx_L0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":841
+ *         return ()
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_child);
+  __Pyx_XDECREF(__pyx_v_fields);
+  __Pyx_XDECREF(__pyx_v_childname);
+  __Pyx_XDECREF(__pyx_v_new_offset);
+  __Pyx_XDECREF(__pyx_v_t);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021
+ *     int _import_umath() except -1
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *     Py_INCREF(base) # important to do this before stealing the reference below!
+ *     PyArray_SetBaseObject(arr, base)
+ */
+
+static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_array_base", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *     Py_INCREF(base) # important to do this before stealing the reference below!             # <<<<<<<<<<<<<<
+ *     PyArray_SetBaseObject(arr, base)
+ * 
+ */
+  Py_INCREF(__pyx_v_base);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *     Py_INCREF(base) # important to do this before stealing the reference below!
+ *     PyArray_SetBaseObject(arr, base)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ */
+  (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base));
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1021
+ *     int _import_umath() except -1
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *     Py_INCREF(base) # important to do this before stealing the reference below!
+ *     PyArray_SetBaseObject(arr, base)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025
+ *     PyArray_SetBaseObject(arr, base)
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     base = PyArray_BASE(arr)
+ *     if base is NULL:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
+  PyObject *__pyx_v_base;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("get_array_base", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     base = PyArray_BASE(arr)             # <<<<<<<<<<<<<<
+ *     if base is NULL:
+ *         return None
+ */
+  __pyx_v_base = PyArray_BASE(__pyx_v_arr);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027
+ * cdef inline object get_array_base(ndarray arr):
+ *     base = PyArray_BASE(arr)
+ *     if base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     return base
+ */
+  __pyx_t_1 = ((__pyx_v_base == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028
+ *     base = PyArray_BASE(arr)
+ *     if base is NULL:
+ *         return None             # <<<<<<<<<<<<<<
+ *     return base
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027
+ * cdef inline object get_array_base(ndarray arr):
+ *     base = PyArray_BASE(arr)
+ *     if base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     return base
+ */
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029
+ *     if base is NULL:
+ *         return None
+ *     return base             # <<<<<<<<<<<<<<
+ * 
+ * # Versions of the import_* functions which are more suitable for
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_base));
+  __pyx_r = ((PyObject *)__pyx_v_base);
+  goto __pyx_L0;
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1025
+ *     PyArray_SetBaseObject(arr, base)
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     base = PyArray_BASE(arr)
+ *     if base is NULL:
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("import_array", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035
+ * cdef inline int import_array() except -1:
+ *     try:
+ *         _import_array()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ */
+      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1035, __pyx_L3_error)
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036
+ *     try:
+ *         _import_array()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1036, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1037, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 1037, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L8_try_end:;
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1033
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("import_umath", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041
+ * cdef inline int import_umath() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1041, __pyx_L3_error)
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1042, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1043, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 1043, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L8_try_end:;
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1039
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("import_ufunc", 0);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047
+ * cdef inline int import_ufunc() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1047, __pyx_L3_error)
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L8_try_end;
+    __pyx_L3_error:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1048, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1049, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(1, 1049, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L8_try_end:;
+  }
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1045
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cfunc.to_py":65
+ * @cname("__Pyx_CFunc_object____object___to_py")
+ * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ):
+ *     def wrap(object x):             # <<<<<<<<<<<<<<
+ *         """wrap(x)"""
+ *         return f(x)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/
+static char __pyx_doc_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap[] = "wrap(x)";
+static PyMethodDef __pyx_mdef_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap = {"wrap", (PyCFunction)__pyx_pw_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap, METH_O, __pyx_doc_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap};
+static PyObject *__pyx_pw_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap(PyObject *__pyx_self, PyObject *__pyx_v_x) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("wrap (wrapper)", 0);
+  __pyx_r = __pyx_pf_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap(__pyx_self, ((PyObject *)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_wrap(PyObject *__pyx_self, PyObject *__pyx_v_x) {
+  struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *__pyx_cur_scope;
+  struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *__pyx_outer_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("wrap", 0);
+  __pyx_outer_scope = (struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_cur_scope = __pyx_outer_scope;
+
+  /* "cfunc.to_py":67
+ *     def wrap(object x):
+ *         """wrap(x)"""
+ *         return f(x)             # <<<<<<<<<<<<<<
+ *     return wrap
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_cur_scope->__pyx_v_f(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "cfunc.to_py":65
+ * @cname("__Pyx_CFunc_object____object___to_py")
+ * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ):
+ *     def wrap(object x):             # <<<<<<<<<<<<<<
+ *         """wrap(x)"""
+ *         return f(x)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_object____object___to_py.wrap", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cfunc.to_py":64
+ * 
+ * @cname("__Pyx_CFunc_object____object___to_py")
+ * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ):             # <<<<<<<<<<<<<<
+ *     def wrap(object x):
+ *         """wrap(x)"""
+ */
+
+static PyObject *__Pyx_CFunc_object____object___to_py(PyObject *(*__pyx_v_f)(PyObject *)) {
+  struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *__pyx_cur_scope;
+  PyObject *__pyx_v_wrap = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_CFunc_object____object___to_py", 0);
+  __pyx_cur_scope = (struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *)__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____object___to_py(__pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____object___to_py, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(2, 64, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF(__pyx_cur_scope);
+  }
+  __pyx_cur_scope->__pyx_v_f = __pyx_v_f;
+
+  /* "cfunc.to_py":65
+ * @cname("__Pyx_CFunc_object____object___to_py")
+ * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ):
+ *     def wrap(object x):             # <<<<<<<<<<<<<<
+ *         """wrap(x)"""
+ *         return f(x)
+ */
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_11cfunc_dot_to_py_36__Pyx_CFunc_object____object___to_py_1wrap, 0, __pyx_n_s_Pyx_CFunc_object____object___t, ((PyObject*)__pyx_cur_scope), __pyx_n_s_cfunc_to_py, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_wrap = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "cfunc.to_py":68
+ *         """wrap(x)"""
+ *         return f(x)
+ *     return wrap             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_wrap);
+  __pyx_r = __pyx_v_wrap;
+  goto __pyx_L0;
+
+  /* "cfunc.to_py":64
+ * 
+ * @cname("__Pyx_CFunc_object____object___to_py")
+ * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ):             # <<<<<<<<<<<<<<
+ *     def wrap(object x):
+ *         """wrap(x)"""
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("cfunc.to_py.__Pyx_CFunc_object____object___to_py", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_wrap);
+  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":122
+ *         cdef bint dtype_is_object
+ * 
+ *     def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,             # <<<<<<<<<<<<<<
+ *                   mode="c", bint allocate_buffer=True):
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_shape = 0;
+  Py_ssize_t __pyx_v_itemsize;
+  PyObject *__pyx_v_format = 0;
+  PyObject *__pyx_v_mode = 0;
+  int __pyx_v_allocate_buffer;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0};
+    PyObject* values[5] = {0,0,0,0,0};
+    values[3] = ((PyObject *)__pyx_n_s_c);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(2, 122, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(2, 122, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode);
+          if (value) { values[3] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer);
+          if (value) { values[4] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 122, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_shape = ((PyObject*)values[0]);
+    __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 122, __pyx_L3_error)
+    __pyx_v_format = values[2];
+    __pyx_v_mode = values[3];
+    if (values[4]) {
+      __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 123, __pyx_L3_error)
+    } else {
+
+      /* "View.MemoryView":123
+ * 
+ *     def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,
+ *                   mode="c", bint allocate_buffer=True):             # <<<<<<<<<<<<<<
+ * 
+ *         cdef int idx
+ */
+      __pyx_v_allocate_buffer = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 122, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(2, 122, __pyx_L1_error)
+  if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) {
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(2, 122, __pyx_L1_error)
+  }
+  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer);
+
+  /* "View.MemoryView":122
+ *         cdef bint dtype_is_object
+ * 
+ *     def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,             # <<<<<<<<<<<<<<
+ *                   mode="c", bint allocate_buffer=True):
+ * 
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) {
+  int __pyx_v_idx;
+  Py_ssize_t __pyx_v_i;
+  Py_ssize_t __pyx_v_dim;
+  PyObject **__pyx_v_p;
+  char __pyx_v_order;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  char *__pyx_t_7;
+  int __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  Py_ssize_t __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_INCREF(__pyx_v_format);
+
+  /* "View.MemoryView":129
+ *         cdef PyObject **p
+ * 
+ *         self.ndim =  len(shape)             # <<<<<<<<<<<<<<
+ *         self.itemsize = itemsize
+ * 
+ */
+  if (unlikely(__pyx_v_shape == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(2, 129, __pyx_L1_error)
+  }
+  __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 129, __pyx_L1_error)
+  __pyx_v_self->ndim = ((int)__pyx_t_1);
+
+  /* "View.MemoryView":130
+ * 
+ *         self.ndim =  len(shape)
+ *         self.itemsize = itemsize             # <<<<<<<<<<<<<<
+ * 
+ *         if not self.ndim:
+ */
+  __pyx_v_self->itemsize = __pyx_v_itemsize;
+
+  /* "View.MemoryView":132
+ *         self.itemsize = itemsize
+ * 
+ *         if not self.ndim:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Empty shape tuple for cython.array")
+ * 
+ */
+  __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "View.MemoryView":133
+ * 
+ *         if not self.ndim:
+ *             raise ValueError("Empty shape tuple for cython.array")             # <<<<<<<<<<<<<<
+ * 
+ *         if itemsize <= 0:
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 133, __pyx_L1_error)
+
+    /* "View.MemoryView":132
+ *         self.itemsize = itemsize
+ * 
+ *         if not self.ndim:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Empty shape tuple for cython.array")
+ * 
+ */
+  }
+
+  /* "View.MemoryView":135
+ *             raise ValueError("Empty shape tuple for cython.array")
+ * 
+ *         if itemsize <= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("itemsize <= 0 for cython.array")
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "View.MemoryView":136
+ * 
+ *         if itemsize <= 0:
+ *             raise ValueError("itemsize <= 0 for cython.array")             # <<<<<<<<<<<<<<
+ * 
+ *         if not isinstance(format, bytes):
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 136, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 136, __pyx_L1_error)
+
+    /* "View.MemoryView":135
+ *             raise ValueError("Empty shape tuple for cython.array")
+ * 
+ *         if itemsize <= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("itemsize <= 0 for cython.array")
+ * 
+ */
+  }
+
+  /* "View.MemoryView":138
+ *             raise ValueError("itemsize <= 0 for cython.array")
+ * 
+ *         if not isinstance(format, bytes):             # <<<<<<<<<<<<<<
+ *             format = format.encode('ASCII')
+ *         self._format = format  # keep a reference to the byte string
+ */
+  __pyx_t_2 = PyBytes_Check(__pyx_v_format); 
+  __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0);
+  if (__pyx_t_4) {
+
+    /* "View.MemoryView":139
+ * 
+ *         if not isinstance(format, bytes):
+ *             format = format.encode('ASCII')             # <<<<<<<<<<<<<<
+ *         self._format = format  # keep a reference to the byte string
+ *         self.format = self._format
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 139, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 139, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "View.MemoryView":138
+ *             raise ValueError("itemsize <= 0 for cython.array")
+ * 
+ *         if not isinstance(format, bytes):             # <<<<<<<<<<<<<<
+ *             format = format.encode('ASCII')
+ *         self._format = format  # keep a reference to the byte string
+ */
+  }
+
+  /* "View.MemoryView":140
+ *         if not isinstance(format, bytes):
+ *             format = format.encode('ASCII')
+ *         self._format = format  # keep a reference to the byte string             # <<<<<<<<<<<<<<
+ *         self.format = self._format
+ * 
+ */
+  if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(2, 140, __pyx_L1_error)
+  __pyx_t_3 = __pyx_v_format;
+  __Pyx_INCREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_3);
+  __Pyx_GOTREF(__pyx_v_self->_format);
+  __Pyx_DECREF(__pyx_v_self->_format);
+  __pyx_v_self->_format = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "View.MemoryView":141
+ *             format = format.encode('ASCII')
+ *         self._format = format  # keep a reference to the byte string
+ *         self.format = self._format             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  if (unlikely(__pyx_v_self->_format == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
+    __PYX_ERR(2, 141, __pyx_L1_error)
+  }
+  __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(2, 141, __pyx_L1_error)
+  __pyx_v_self->format = __pyx_t_7;
+
+  /* "View.MemoryView":144
+ * 
+ * 
+ *         self._shape =  PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2)             # <<<<<<<<<<<<<<
+ *         self._strides = self._shape + self.ndim
+ * 
+ */
+  __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2)));
+
+  /* "View.MemoryView":145
+ * 
+ *         self._shape =  PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2)
+ *         self._strides = self._shape + self.ndim             # <<<<<<<<<<<<<<
+ * 
+ *         if not self._shape:
+ */
+  __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim);
+
+  /* "View.MemoryView":147
+ *         self._strides = self._shape + self.ndim
+ * 
+ *         if not self._shape:             # <<<<<<<<<<<<<<
+ *             raise MemoryError("unable to allocate shape and strides.")
+ * 
+ */
+  __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0);
+  if (unlikely(__pyx_t_4)) {
+
+    /* "View.MemoryView":148
+ * 
+ *         if not self._shape:
+ *             raise MemoryError("unable to allocate shape and strides.")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 148, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 148, __pyx_L1_error)
+
+    /* "View.MemoryView":147
+ *         self._strides = self._shape + self.ndim
+ * 
+ *         if not self._shape:             # <<<<<<<<<<<<<<
+ *             raise MemoryError("unable to allocate shape and strides.")
+ * 
+ */
+  }
+
+  /* "View.MemoryView":151
+ * 
+ * 
+ *         for idx, dim in enumerate(shape):             # <<<<<<<<<<<<<<
+ *             if dim <= 0:
+ *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
+ */
+  __pyx_t_8 = 0;
+  __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+  for (;;) {
+    if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(2, 151, __pyx_L1_error)
+    #else
+    __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 151, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    #endif
+    __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 151, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_v_dim = __pyx_t_9;
+    __pyx_v_idx = __pyx_t_8;
+    __pyx_t_8 = (__pyx_t_8 + 1);
+
+    /* "View.MemoryView":152
+ * 
+ *         for idx, dim in enumerate(shape):
+ *             if dim <= 0:             # <<<<<<<<<<<<<<
+ *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
+ *             self._shape[idx] = dim
+ */
+    __pyx_t_4 = ((__pyx_v_dim <= 0) != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "View.MemoryView":153
+ *         for idx, dim in enumerate(shape):
+ *             if dim <= 0:
+ *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))             # <<<<<<<<<<<<<<
+ *             self._shape[idx] = dim
+ * 
+ */
+      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6);
+      __pyx_t_5 = 0;
+      __pyx_t_6 = 0;
+      __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 153, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_Raise(__pyx_t_10, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __PYX_ERR(2, 153, __pyx_L1_error)
+
+      /* "View.MemoryView":152
+ * 
+ *         for idx, dim in enumerate(shape):
+ *             if dim <= 0:             # <<<<<<<<<<<<<<
+ *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
+ *             self._shape[idx] = dim
+ */
+    }
+
+    /* "View.MemoryView":154
+ *             if dim <= 0:
+ *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
+ *             self._shape[idx] = dim             # <<<<<<<<<<<<<<
+ * 
+ *         cdef char order
+ */
+    (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim;
+
+    /* "View.MemoryView":151
+ * 
+ * 
+ *         for idx, dim in enumerate(shape):             # <<<<<<<<<<<<<<
+ *             if dim <= 0:
+ *                 raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "View.MemoryView":157
+ * 
+ *         cdef char order
+ *         if mode == 'fortran':             # <<<<<<<<<<<<<<
+ *             order = b'F'
+ *             self.mode = u'fortran'
+ */
+  __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 157, __pyx_L1_error)
+  if (__pyx_t_4) {
+
+    /* "View.MemoryView":158
+ *         cdef char order
+ *         if mode == 'fortran':
+ *             order = b'F'             # <<<<<<<<<<<<<<
+ *             self.mode = u'fortran'
+ *         elif mode == 'c':
+ */
+    __pyx_v_order = 'F';
+
+    /* "View.MemoryView":159
+ *         if mode == 'fortran':
+ *             order = b'F'
+ *             self.mode = u'fortran'             # <<<<<<<<<<<<<<
+ *         elif mode == 'c':
+ *             order = b'C'
+ */
+    __Pyx_INCREF(__pyx_n_u_fortran);
+    __Pyx_GIVEREF(__pyx_n_u_fortran);
+    __Pyx_GOTREF(__pyx_v_self->mode);
+    __Pyx_DECREF(__pyx_v_self->mode);
+    __pyx_v_self->mode = __pyx_n_u_fortran;
+
+    /* "View.MemoryView":157
+ * 
+ *         cdef char order
+ *         if mode == 'fortran':             # <<<<<<<<<<<<<<
+ *             order = b'F'
+ *             self.mode = u'fortran'
+ */
+    goto __pyx_L10;
+  }
+
+  /* "View.MemoryView":160
+ *             order = b'F'
+ *             self.mode = u'fortran'
+ *         elif mode == 'c':             # <<<<<<<<<<<<<<
+ *             order = b'C'
+ *             self.mode = u'c'
+ */
+  __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 160, __pyx_L1_error)
+  if (likely(__pyx_t_4)) {
+
+    /* "View.MemoryView":161
+ *             self.mode = u'fortran'
+ *         elif mode == 'c':
+ *             order = b'C'             # <<<<<<<<<<<<<<
+ *             self.mode = u'c'
+ *         else:
+ */
+    __pyx_v_order = 'C';
+
+    /* "View.MemoryView":162
+ *         elif mode == 'c':
+ *             order = b'C'
+ *             self.mode = u'c'             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)
+ */
+    __Pyx_INCREF(__pyx_n_u_c);
+    __Pyx_GIVEREF(__pyx_n_u_c);
+    __Pyx_GOTREF(__pyx_v_self->mode);
+    __Pyx_DECREF(__pyx_v_self->mode);
+    __pyx_v_self->mode = __pyx_n_u_c;
+
+    /* "View.MemoryView":160
+ *             order = b'F'
+ *             self.mode = u'fortran'
+ *         elif mode == 'c':             # <<<<<<<<<<<<<<
+ *             order = b'C'
+ *             self.mode = u'c'
+ */
+    goto __pyx_L10;
+  }
+
+  /* "View.MemoryView":164
+ *             self.mode = u'c'
+ *         else:
+ *             raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)             # <<<<<<<<<<<<<<
+ * 
+ *         self.len = fill_contig_strides_array(self._shape, self._strides,
+ */
+  /*else*/ {
+    __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 164, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 164, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_10, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __PYX_ERR(2, 164, __pyx_L1_error)
+  }
+  __pyx_L10:;
+
+  /* "View.MemoryView":166
+ *             raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)
+ * 
+ *         self.len = fill_contig_strides_array(self._shape, self._strides,             # <<<<<<<<<<<<<<
+ *                                              itemsize, self.ndim, order)
+ * 
+ */
+  __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order);
+
+  /* "View.MemoryView":169
+ *                                              itemsize, self.ndim, order)
+ * 
+ *         self.free_data = allocate_buffer             # <<<<<<<<<<<<<<
+ *         self.dtype_is_object = format == b'O'
+ *         if allocate_buffer:
+ */
+  __pyx_v_self->free_data = __pyx_v_allocate_buffer;
+
+  /* "View.MemoryView":170
+ * 
+ *         self.free_data = allocate_buffer
+ *         self.dtype_is_object = format == b'O'             # <<<<<<<<<<<<<<
+ *         if allocate_buffer:
+ * 
+ */
+  __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 170, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 170, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+  __pyx_v_self->dtype_is_object = __pyx_t_4;
+
+  /* "View.MemoryView":171
+ *         self.free_data = allocate_buffer
+ *         self.dtype_is_object = format == b'O'
+ *         if allocate_buffer:             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_4 = (__pyx_v_allocate_buffer != 0);
+  if (__pyx_t_4) {
+
+    /* "View.MemoryView":174
+ * 
+ * 
+ *             self.data = malloc(self.len)             # <<<<<<<<<<<<<<
+ *             if not self.data:
+ *                 raise MemoryError("unable to allocate array data.")
+ */
+    __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len));
+
+    /* "View.MemoryView":175
+ * 
+ *             self.data = malloc(self.len)
+ *             if not self.data:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError("unable to allocate array data.")
+ * 
+ */
+    __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "View.MemoryView":176
+ *             self.data = malloc(self.len)
+ *             if not self.data:
+ *                 raise MemoryError("unable to allocate array data.")             # <<<<<<<<<<<<<<
+ * 
+ *             if self.dtype_is_object:
+ */
+      __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 176, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_Raise(__pyx_t_10, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __PYX_ERR(2, 176, __pyx_L1_error)
+
+      /* "View.MemoryView":175
+ * 
+ *             self.data = malloc(self.len)
+ *             if not self.data:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError("unable to allocate array data.")
+ * 
+ */
+    }
+
+    /* "View.MemoryView":178
+ *                 raise MemoryError("unable to allocate array data.")
+ * 
+ *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
+ *                 p =  self.data
+ *                 for i in range(self.len / itemsize):
+ */
+    __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0);
+    if (__pyx_t_4) {
+
+      /* "View.MemoryView":179
+ * 
+ *             if self.dtype_is_object:
+ *                 p =  self.data             # <<<<<<<<<<<<<<
+ *                 for i in range(self.len / itemsize):
+ *                     p[i] = Py_None
+ */
+      __pyx_v_p = ((PyObject **)__pyx_v_self->data);
+
+      /* "View.MemoryView":180
+ *             if self.dtype_is_object:
+ *                 p =  self.data
+ *                 for i in range(self.len / itemsize):             # <<<<<<<<<<<<<<
+ *                     p[i] = Py_None
+ *                     Py_INCREF(Py_None)
+ */
+      if (unlikely(__pyx_v_itemsize == 0)) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
+        __PYX_ERR(2, 180, __pyx_L1_error)
+      }
+      else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1)  && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) {
+        PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
+        __PYX_ERR(2, 180, __pyx_L1_error)
+      }
+      __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize);
+      __pyx_t_9 = __pyx_t_1;
+      for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) {
+        __pyx_v_i = __pyx_t_11;
+
+        /* "View.MemoryView":181
+ *                 p =  self.data
+ *                 for i in range(self.len / itemsize):
+ *                     p[i] = Py_None             # <<<<<<<<<<<<<<
+ *                     Py_INCREF(Py_None)
+ * 
+ */
+        (__pyx_v_p[__pyx_v_i]) = Py_None;
+
+        /* "View.MemoryView":182
+ *                 for i in range(self.len / itemsize):
+ *                     p[i] = Py_None
+ *                     Py_INCREF(Py_None)             # <<<<<<<<<<<<<<
+ * 
+ *     @cname('getbuffer')
+ */
+        Py_INCREF(Py_None);
+      }
+
+      /* "View.MemoryView":178
+ *                 raise MemoryError("unable to allocate array data.")
+ * 
+ *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
+ *                 p =  self.data
+ *                 for i in range(self.len / itemsize):
+ */
+    }
+
+    /* "View.MemoryView":171
+ *         self.free_data = allocate_buffer
+ *         self.dtype_is_object = format == b'O'
+ *         if allocate_buffer:             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  }
+
+  /* "View.MemoryView":122
+ *         cdef bint dtype_is_object
+ * 
+ *     def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,             # <<<<<<<<<<<<<<
+ *                   mode="c", bint allocate_buffer=True):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_format);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":185
+ * 
+ *     @cname('getbuffer')
+ *     def __getbuffer__(self, Py_buffer *info, int flags):             # <<<<<<<<<<<<<<
+ *         cdef int bufmode = -1
+ *         if self.mode == u"c":
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_v_bufmode;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  char *__pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  int __pyx_t_6;
+  Py_ssize_t *__pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  if (__pyx_v_info == NULL) {
+    PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
+    return -1;
+  }
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(__pyx_v_info->obj);
+
+  /* "View.MemoryView":186
+ *     @cname('getbuffer')
+ *     def __getbuffer__(self, Py_buffer *info, int flags):
+ *         cdef int bufmode = -1             # <<<<<<<<<<<<<<
+ *         if self.mode == u"c":
+ *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ */
+  __pyx_v_bufmode = -1;
+
+  /* "View.MemoryView":187
+ *     def __getbuffer__(self, Py_buffer *info, int flags):
+ *         cdef int bufmode = -1
+ *         if self.mode == u"c":             # <<<<<<<<<<<<<<
+ *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         elif self.mode == u"fortran":
+ */
+  __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 187, __pyx_L1_error)
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":188
+ *         cdef int bufmode = -1
+ *         if self.mode == u"c":
+ *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS             # <<<<<<<<<<<<<<
+ *         elif self.mode == u"fortran":
+ *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ */
+    __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
+
+    /* "View.MemoryView":187
+ *     def __getbuffer__(self, Py_buffer *info, int flags):
+ *         cdef int bufmode = -1
+ *         if self.mode == u"c":             # <<<<<<<<<<<<<<
+ *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         elif self.mode == u"fortran":
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":189
+ *         if self.mode == u"c":
+ *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         elif self.mode == u"fortran":             # <<<<<<<<<<<<<<
+ *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         if not (flags & bufmode):
+ */
+  __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 189, __pyx_L1_error)
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":190
+ *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         elif self.mode == u"fortran":
+ *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS             # <<<<<<<<<<<<<<
+ *         if not (flags & bufmode):
+ *             raise ValueError("Can only create a buffer that is contiguous in memory.")
+ */
+    __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS);
+
+    /* "View.MemoryView":189
+ *         if self.mode == u"c":
+ *             bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         elif self.mode == u"fortran":             # <<<<<<<<<<<<<<
+ *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         if not (flags & bufmode):
+ */
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":191
+ *         elif self.mode == u"fortran":
+ *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         if not (flags & bufmode):             # <<<<<<<<<<<<<<
+ *             raise ValueError("Can only create a buffer that is contiguous in memory.")
+ *         info.buf = self.data
+ */
+  __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "View.MemoryView":192
+ *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         if not (flags & bufmode):
+ *             raise ValueError("Can only create a buffer that is contiguous in memory.")             # <<<<<<<<<<<<<<
+ *         info.buf = self.data
+ *         info.len = self.len
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 192, __pyx_L1_error)
+
+    /* "View.MemoryView":191
+ *         elif self.mode == u"fortran":
+ *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         if not (flags & bufmode):             # <<<<<<<<<<<<<<
+ *             raise ValueError("Can only create a buffer that is contiguous in memory.")
+ *         info.buf = self.data
+ */
+  }
+
+  /* "View.MemoryView":193
+ *         if not (flags & bufmode):
+ *             raise ValueError("Can only create a buffer that is contiguous in memory.")
+ *         info.buf = self.data             # <<<<<<<<<<<<<<
+ *         info.len = self.len
+ *         info.ndim = self.ndim
+ */
+  __pyx_t_4 = __pyx_v_self->data;
+  __pyx_v_info->buf = __pyx_t_4;
+
+  /* "View.MemoryView":194
+ *             raise ValueError("Can only create a buffer that is contiguous in memory.")
+ *         info.buf = self.data
+ *         info.len = self.len             # <<<<<<<<<<<<<<
+ *         info.ndim = self.ndim
+ *         info.shape = self._shape
+ */
+  __pyx_t_5 = __pyx_v_self->len;
+  __pyx_v_info->len = __pyx_t_5;
+
+  /* "View.MemoryView":195
+ *         info.buf = self.data
+ *         info.len = self.len
+ *         info.ndim = self.ndim             # <<<<<<<<<<<<<<
+ *         info.shape = self._shape
+ *         info.strides = self._strides
+ */
+  __pyx_t_6 = __pyx_v_self->ndim;
+  __pyx_v_info->ndim = __pyx_t_6;
+
+  /* "View.MemoryView":196
+ *         info.len = self.len
+ *         info.ndim = self.ndim
+ *         info.shape = self._shape             # <<<<<<<<<<<<<<
+ *         info.strides = self._strides
+ *         info.suboffsets = NULL
+ */
+  __pyx_t_7 = __pyx_v_self->_shape;
+  __pyx_v_info->shape = __pyx_t_7;
+
+  /* "View.MemoryView":197
+ *         info.ndim = self.ndim
+ *         info.shape = self._shape
+ *         info.strides = self._strides             # <<<<<<<<<<<<<<
+ *         info.suboffsets = NULL
+ *         info.itemsize = self.itemsize
+ */
+  __pyx_t_7 = __pyx_v_self->_strides;
+  __pyx_v_info->strides = __pyx_t_7;
+
+  /* "View.MemoryView":198
+ *         info.shape = self._shape
+ *         info.strides = self._strides
+ *         info.suboffsets = NULL             # <<<<<<<<<<<<<<
+ *         info.itemsize = self.itemsize
+ *         info.readonly = 0
+ */
+  __pyx_v_info->suboffsets = NULL;
+
+  /* "View.MemoryView":199
+ *         info.strides = self._strides
+ *         info.suboffsets = NULL
+ *         info.itemsize = self.itemsize             # <<<<<<<<<<<<<<
+ *         info.readonly = 0
+ * 
+ */
+  __pyx_t_5 = __pyx_v_self->itemsize;
+  __pyx_v_info->itemsize = __pyx_t_5;
+
+  /* "View.MemoryView":200
+ *         info.suboffsets = NULL
+ *         info.itemsize = self.itemsize
+ *         info.readonly = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if flags & PyBUF_FORMAT:
+ */
+  __pyx_v_info->readonly = 0;
+
+  /* "View.MemoryView":202
+ *         info.readonly = 0
+ * 
+ *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
+ *             info.format = self.format
+ *         else:
+ */
+  __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":203
+ * 
+ *         if flags & PyBUF_FORMAT:
+ *             info.format = self.format             # <<<<<<<<<<<<<<
+ *         else:
+ *             info.format = NULL
+ */
+    __pyx_t_4 = __pyx_v_self->format;
+    __pyx_v_info->format = __pyx_t_4;
+
+    /* "View.MemoryView":202
+ *         info.readonly = 0
+ * 
+ *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
+ *             info.format = self.format
+ *         else:
+ */
+    goto __pyx_L5;
+  }
+
+  /* "View.MemoryView":205
+ *             info.format = self.format
+ *         else:
+ *             info.format = NULL             # <<<<<<<<<<<<<<
+ * 
+ *         info.obj = self
+ */
+  /*else*/ {
+    __pyx_v_info->format = NULL;
+  }
+  __pyx_L5:;
+
+  /* "View.MemoryView":207
+ *             info.format = NULL
+ * 
+ *         info.obj = self             # <<<<<<<<<<<<<<
+ * 
+ *     __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  __Pyx_GOTREF(__pyx_v_info->obj);
+  __Pyx_DECREF(__pyx_v_info->obj);
+  __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+
+  /* "View.MemoryView":185
+ * 
+ *     @cname('getbuffer')
+ *     def __getbuffer__(self, Py_buffer *info, int flags):             # <<<<<<<<<<<<<<
+ *         cdef int bufmode = -1
+ *         if self.mode == u"c":
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_info->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_info->obj == Py_None) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+  }
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":211
+ *     __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
+ * 
+ *     def __dealloc__(array self):             # <<<<<<<<<<<<<<
+ *         if self.callback_free_data != NULL:
+ *             self.callback_free_data(self.data)
+ */
+
+/* Python wrapper */
+static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_array___dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "View.MemoryView":212
+ * 
+ *     def __dealloc__(array self):
+ *         if self.callback_free_data != NULL:             # <<<<<<<<<<<<<<
+ *             self.callback_free_data(self.data)
+ *         elif self.free_data:
+ */
+  __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":213
+ *     def __dealloc__(array self):
+ *         if self.callback_free_data != NULL:
+ *             self.callback_free_data(self.data)             # <<<<<<<<<<<<<<
+ *         elif self.free_data:
+ *             if self.dtype_is_object:
+ */
+    __pyx_v_self->callback_free_data(__pyx_v_self->data);
+
+    /* "View.MemoryView":212
+ * 
+ *     def __dealloc__(array self):
+ *         if self.callback_free_data != NULL:             # <<<<<<<<<<<<<<
+ *             self.callback_free_data(self.data)
+ *         elif self.free_data:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":214
+ *         if self.callback_free_data != NULL:
+ *             self.callback_free_data(self.data)
+ *         elif self.free_data:             # <<<<<<<<<<<<<<
+ *             if self.dtype_is_object:
+ *                 refcount_objects_in_slice(self.data, self._shape,
+ */
+  __pyx_t_1 = (__pyx_v_self->free_data != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":215
+ *             self.callback_free_data(self.data)
+ *         elif self.free_data:
+ *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
+ *                 refcount_objects_in_slice(self.data, self._shape,
+ *                                           self._strides, self.ndim, False)
+ */
+    __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0);
+    if (__pyx_t_1) {
+
+      /* "View.MemoryView":216
+ *         elif self.free_data:
+ *             if self.dtype_is_object:
+ *                 refcount_objects_in_slice(self.data, self._shape,             # <<<<<<<<<<<<<<
+ *                                           self._strides, self.ndim, False)
+ *             free(self.data)
+ */
+      __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0);
+
+      /* "View.MemoryView":215
+ *             self.callback_free_data(self.data)
+ *         elif self.free_data:
+ *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
+ *                 refcount_objects_in_slice(self.data, self._shape,
+ *                                           self._strides, self.ndim, False)
+ */
+    }
+
+    /* "View.MemoryView":218
+ *                 refcount_objects_in_slice(self.data, self._shape,
+ *                                           self._strides, self.ndim, False)
+ *             free(self.data)             # <<<<<<<<<<<<<<
+ *         PyObject_Free(self._shape)
+ * 
+ */
+    free(__pyx_v_self->data);
+
+    /* "View.MemoryView":214
+ *         if self.callback_free_data != NULL:
+ *             self.callback_free_data(self.data)
+ *         elif self.free_data:             # <<<<<<<<<<<<<<
+ *             if self.dtype_is_object:
+ *                 refcount_objects_in_slice(self.data, self._shape,
+ */
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":219
+ *                                           self._strides, self.ndim, False)
+ *             free(self.data)
+ *         PyObject_Free(self._shape)             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  PyObject_Free(__pyx_v_self->_shape);
+
+  /* "View.MemoryView":211
+ *     __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")
+ * 
+ *     def __dealloc__(array self):             # <<<<<<<<<<<<<<
+ *         if self.callback_free_data != NULL:
+ *             self.callback_free_data(self.data)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":222
+ * 
+ *     @property
+ *     def memview(self):             # <<<<<<<<<<<<<<
+ *         return self.get_memview()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":223
+ *     @property
+ *     def memview(self):
+ *         return self.get_memview()             # <<<<<<<<<<<<<<
+ * 
+ *     @cname('get_memview')
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":222
+ * 
+ *     @property
+ *     def memview(self):             # <<<<<<<<<<<<<<
+ *         return self.get_memview()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":226
+ * 
+ *     @cname('get_memview')
+ *     cdef get_memview(self):             # <<<<<<<<<<<<<<
+ *         flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
+ *         return  memoryview(self, flags, self.dtype_is_object)
+ */
+
+static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) {
+  int __pyx_v_flags;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_memview", 0);
+
+  /* "View.MemoryView":227
+ *     @cname('get_memview')
+ *     cdef get_memview(self):
+ *         flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE             # <<<<<<<<<<<<<<
+ *         return  memoryview(self, flags, self.dtype_is_object)
+ * 
+ */
+  __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE);
+
+  /* "View.MemoryView":228
+ *     cdef get_memview(self):
+ *         flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
+ *         return  memoryview(self, flags, self.dtype_is_object)             # <<<<<<<<<<<<<<
+ * 
+ *     def __len__(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":226
+ * 
+ *     @cname('get_memview')
+ *     cdef get_memview(self):             # <<<<<<<<<<<<<<
+ *         flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
+ *         return  memoryview(self, flags, self.dtype_is_object)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":230
+ *         return  memoryview(self, flags, self.dtype_is_object)
+ * 
+ *     def __len__(self):             # <<<<<<<<<<<<<<
+ *         return self._shape[0]
+ * 
+ */
+
+/* Python wrapper */
+static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/
+static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) {
+  Py_ssize_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
+  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) {
+  Py_ssize_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__len__", 0);
+
+  /* "View.MemoryView":231
+ * 
+ *     def __len__(self):
+ *         return self._shape[0]             # <<<<<<<<<<<<<<
+ * 
+ *     def __getattr__(self, attr):
+ */
+  __pyx_r = (__pyx_v_self->_shape[0]);
+  goto __pyx_L0;
+
+  /* "View.MemoryView":230
+ *         return  memoryview(self, flags, self.dtype_is_object)
+ * 
+ *     def __len__(self):             # <<<<<<<<<<<<<<
+ *         return self._shape[0]
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":233
+ *         return self._shape[0]
+ * 
+ *     def __getattr__(self, attr):             # <<<<<<<<<<<<<<
+ *         return getattr(self.memview, attr)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/
+static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0);
+  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__getattr__", 0);
+
+  /* "View.MemoryView":234
+ * 
+ *     def __getattr__(self, attr):
+ *         return getattr(self.memview, attr)             # <<<<<<<<<<<<<<
+ * 
+ *     def __getitem__(self, item):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":233
+ *         return self._shape[0]
+ * 
+ *     def __getattr__(self, attr):             # <<<<<<<<<<<<<<
+ *         return getattr(self.memview, attr)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":236
+ *         return getattr(self.memview, attr)
+ * 
+ *     def __getitem__(self, item):             # <<<<<<<<<<<<<<
+ *         return self.memview[item]
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/
+static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
+
+  /* "View.MemoryView":237
+ * 
+ *     def __getitem__(self, item):
+ *         return self.memview[item]             # <<<<<<<<<<<<<<
+ * 
+ *     def __setitem__(self, item, value):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":236
+ *         return getattr(self.memview, attr)
+ * 
+ *     def __getitem__(self, item):             # <<<<<<<<<<<<<<
+ *         return self.memview[item]
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":239
+ *         return self.memview[item]
+ * 
+ *     def __setitem__(self, item, value):             # <<<<<<<<<<<<<<
+ *         self.memview[item] = value
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/
+static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
+  __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__setitem__", 0);
+
+  /* "View.MemoryView":240
+ * 
+ *     def __setitem__(self, item, value):
+ *         self.memview[item] = value             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(2, 240, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "View.MemoryView":239
+ *         return self.memview[item]
+ * 
+ *     def __setitem__(self, item, value):             # <<<<<<<<<<<<<<
+ *         self.memview[item] = value
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __PYX_ERR(2, 2, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+  __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __PYX_ERR(2, 4, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":244
+ * 
+ * @cname("__pyx_array_new")
+ * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format,             # <<<<<<<<<<<<<<
+ *                           char *mode, char *buf):
+ *     cdef array result
+ */
+
+static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) {
+  struct __pyx_array_obj *__pyx_v_result = 0;
+  struct __pyx_array_obj *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("array_cwrapper", 0);
+
+  /* "View.MemoryView":248
+ *     cdef array result
+ * 
+ *     if buf == NULL:             # <<<<<<<<<<<<<<
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'))
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_buf == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":249
+ * 
+ *     if buf == NULL:
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'))             # <<<<<<<<<<<<<<
+ *     else:
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'),
+ */
+    __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 249, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 249, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 249, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 249, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_v_shape);
+    __Pyx_GIVEREF(__pyx_v_shape);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape);
+    __Pyx_GIVEREF(__pyx_t_2);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4);
+    __pyx_t_2 = 0;
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 249, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "View.MemoryView":248
+ *     cdef array result
+ * 
+ *     if buf == NULL:             # <<<<<<<<<<<<<<
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'))
+ *     else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":251
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'))
+ *     else:
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'),             # <<<<<<<<<<<<<<
+ *                        allocate_buffer=False)
+ *         result.data = buf
+ */
+  /*else*/ {
+    __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 251, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 251, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 251, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 251, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_v_shape);
+    __Pyx_GIVEREF(__pyx_v_shape);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_3 = 0;
+
+    /* "View.MemoryView":252
+ *     else:
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'),
+ *                        allocate_buffer=False)             # <<<<<<<<<<<<<<
+ *         result.data = buf
+ * 
+ */
+    __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 252, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(2, 252, __pyx_L1_error)
+
+    /* "View.MemoryView":251
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'))
+ *     else:
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'),             # <<<<<<<<<<<<<<
+ *                        allocate_buffer=False)
+ *         result.data = buf
+ */
+    __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 251, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "View.MemoryView":253
+ *         result = array(shape, itemsize, format, mode.decode('ASCII'),
+ *                        allocate_buffer=False)
+ *         result.data = buf             # <<<<<<<<<<<<<<
+ * 
+ *     return result
+ */
+    __pyx_v_result->data = __pyx_v_buf;
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":255
+ *         result.data = buf
+ * 
+ *     return result             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(((PyObject *)__pyx_r));
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":244
+ * 
+ * @cname("__pyx_array_new")
+ * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format,             # <<<<<<<<<<<<<<
+ *                           char *mode, char *buf):
+ *     cdef array result
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":281
+ * cdef class Enum(object):
+ *     cdef object name
+ *     def __init__(self, name):             # <<<<<<<<<<<<<<
+ *         self.name = name
+ *     def __repr__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_name = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(2, 281, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_name = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 281, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  /* "View.MemoryView":282
+ *     cdef object name
+ *     def __init__(self, name):
+ *         self.name = name             # <<<<<<<<<<<<<<
+ *     def __repr__(self):
+ *         return self.name
+ */
+  __Pyx_INCREF(__pyx_v_name);
+  __Pyx_GIVEREF(__pyx_v_name);
+  __Pyx_GOTREF(__pyx_v_self->name);
+  __Pyx_DECREF(__pyx_v_self->name);
+  __pyx_v_self->name = __pyx_v_name;
+
+  /* "View.MemoryView":281
+ * cdef class Enum(object):
+ *     cdef object name
+ *     def __init__(self, name):             # <<<<<<<<<<<<<<
+ *         self.name = name
+ *     def __repr__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":283
+ *     def __init__(self, name):
+ *         self.name = name
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return self.name
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "View.MemoryView":284
+ *         self.name = name
+ *     def __repr__(self):
+ *         return self.name             # <<<<<<<<<<<<<<
+ * 
+ * cdef generic = Enum("")
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->name);
+  __pyx_r = __pyx_v_self->name;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":283
+ *     def __init__(self, name):
+ *         self.name = name
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return self.name
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) {
+  PyObject *__pyx_v_state = 0;
+  PyObject *__pyx_v__dict = 0;
+  int __pyx_v_use_setstate;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+  /* "(tree fragment)":5
+ *     cdef object _dict
+ *     cdef bint use_setstate
+ *     state = (self.name,)             # <<<<<<<<<<<<<<
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_v_self->name);
+  __Pyx_GIVEREF(__pyx_v_self->name);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name);
+  __pyx_v_state = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "(tree fragment)":6
+ *     cdef bint use_setstate
+ *     state = (self.name,)
+ *     _dict = getattr(self, '__dict__', None)             # <<<<<<<<<<<<<<
+ *     if _dict is not None:
+ *         state += (_dict,)
+ */
+  __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v__dict = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "(tree fragment)":7
+ *     state = (self.name,)
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:             # <<<<<<<<<<<<<<
+ *         state += (_dict,)
+ *         use_setstate = True
+ */
+  __pyx_t_2 = (__pyx_v__dict != Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "(tree fragment)":8
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:
+ *         state += (_dict,)             # <<<<<<<<<<<<<<
+ *         use_setstate = True
+ *     else:
+ */
+    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_v__dict);
+    __Pyx_GIVEREF(__pyx_v__dict);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict);
+    __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4));
+    __pyx_t_4 = 0;
+
+    /* "(tree fragment)":9
+ *     if _dict is not None:
+ *         state += (_dict,)
+ *         use_setstate = True             # <<<<<<<<<<<<<<
+ *     else:
+ *         use_setstate = self.name is not None
+ */
+    __pyx_v_use_setstate = 1;
+
+    /* "(tree fragment)":7
+ *     state = (self.name,)
+ *     _dict = getattr(self, '__dict__', None)
+ *     if _dict is not None:             # <<<<<<<<<<<<<<
+ *         state += (_dict,)
+ *         use_setstate = True
+ */
+    goto __pyx_L3;
+  }
+
+  /* "(tree fragment)":11
+ *         use_setstate = True
+ *     else:
+ *         use_setstate = self.name is not None             # <<<<<<<<<<<<<<
+ *     if use_setstate:
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
+ */
+  /*else*/ {
+    __pyx_t_3 = (__pyx_v_self->name != Py_None);
+    __pyx_v_use_setstate = __pyx_t_3;
+  }
+  __pyx_L3:;
+
+  /* "(tree fragment)":12
+ *     else:
+ *         use_setstate = self.name is not None
+ *     if use_setstate:             # <<<<<<<<<<<<<<
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
+ *     else:
+ */
+  __pyx_t_3 = (__pyx_v_use_setstate != 0);
+  if (__pyx_t_3) {
+
+    /* "(tree fragment)":13
+ *         use_setstate = self.name is not None
+ *     if use_setstate:
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state             # <<<<<<<<<<<<<<
+ *     else:
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_INCREF(__pyx_int_184977713);
+    __Pyx_GIVEREF(__pyx_int_184977713);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713);
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None);
+    __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
+    __Pyx_INCREF(__pyx_v_state);
+    __Pyx_GIVEREF(__pyx_v_state);
+    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state);
+    __pyx_t_4 = 0;
+    __pyx_t_1 = 0;
+    __pyx_r = __pyx_t_5;
+    __pyx_t_5 = 0;
+    goto __pyx_L0;
+
+    /* "(tree fragment)":12
+ *     else:
+ *         use_setstate = self.name is not None
+ *     if use_setstate:             # <<<<<<<<<<<<<<
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
+ *     else:
+ */
+  }
+
+  /* "(tree fragment)":15
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state
+ *     else:
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     __pyx_unpickle_Enum__set_state(self, __pyx_state)
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+    __Pyx_INCREF(__pyx_int_184977713);
+    __Pyx_GIVEREF(__pyx_int_184977713);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713);
+    __Pyx_INCREF(__pyx_v_state);
+    __Pyx_GIVEREF(__pyx_v_state);
+    PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state);
+    __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
+    __pyx_t_5 = 0;
+    __pyx_t_1 = 0;
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_state);
+  __Pyx_XDECREF(__pyx_v__dict);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Enum__set_state(self, __pyx_state)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+  __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+
+  /* "(tree fragment)":17
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
+ * def __setstate_cython__(self, __pyx_state):
+ *     __pyx_unpickle_Enum__set_state(self, __pyx_state)             # <<<<<<<<<<<<<<
+ */
+  if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error)
+  __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Enum, (type(self), 0xb068931, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Enum__set_state(self, __pyx_state)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":298
+ * 
+ * @cname('__pyx_align_pointer')
+ * cdef void *align_pointer(void *memory, size_t alignment) nogil:             # <<<<<<<<<<<<<<
+ *     "Align pointer memory on a given boundary"
+ *     cdef Py_intptr_t aligned_p =  memory
+ */
+
+static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) {
+  Py_intptr_t __pyx_v_aligned_p;
+  size_t __pyx_v_offset;
+  void *__pyx_r;
+  int __pyx_t_1;
+
+  /* "View.MemoryView":300
+ * cdef void *align_pointer(void *memory, size_t alignment) nogil:
+ *     "Align pointer memory on a given boundary"
+ *     cdef Py_intptr_t aligned_p =  memory             # <<<<<<<<<<<<<<
+ *     cdef size_t offset
+ * 
+ */
+  __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory);
+
+  /* "View.MemoryView":304
+ * 
+ *     with cython.cdivision(True):
+ *         offset = aligned_p % alignment             # <<<<<<<<<<<<<<
+ * 
+ *     if offset > 0:
+ */
+  __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment);
+
+  /* "View.MemoryView":306
+ *         offset = aligned_p % alignment
+ * 
+ *     if offset > 0:             # <<<<<<<<<<<<<<
+ *         aligned_p += alignment - offset
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_offset > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":307
+ * 
+ *     if offset > 0:
+ *         aligned_p += alignment - offset             # <<<<<<<<<<<<<<
+ * 
+ *     return  aligned_p
+ */
+    __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset));
+
+    /* "View.MemoryView":306
+ *         offset = aligned_p % alignment
+ * 
+ *     if offset > 0:             # <<<<<<<<<<<<<<
+ *         aligned_p += alignment - offset
+ * 
+ */
+  }
+
+  /* "View.MemoryView":309
+ *         aligned_p += alignment - offset
+ * 
+ *     return  aligned_p             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = ((void *)__pyx_v_aligned_p);
+  goto __pyx_L0;
+
+  /* "View.MemoryView":298
+ * 
+ * @cname('__pyx_align_pointer')
+ * cdef void *align_pointer(void *memory, size_t alignment) nogil:             # <<<<<<<<<<<<<<
+ *     "Align pointer memory on a given boundary"
+ *     cdef Py_intptr_t aligned_p =  memory
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":345
+ *     cdef __Pyx_TypeInfo *typeinfo
+ * 
+ *     def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):             # <<<<<<<<<<<<<<
+ *         self.obj = obj
+ *         self.flags = flags
+ */
+
+/* Python wrapper */
+static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_obj = 0;
+  int __pyx_v_flags;
+  int __pyx_v_dtype_is_object;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(2, 345, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 345, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_obj = values[0];
+    __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 345, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 345, __pyx_L3_error)
+    } else {
+      __pyx_v_dtype_is_object = ((int)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 345, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "View.MemoryView":346
+ * 
+ *     def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
+ *         self.obj = obj             # <<<<<<<<<<<<<<
+ *         self.flags = flags
+ *         if type(self) is memoryview or obj is not None:
+ */
+  __Pyx_INCREF(__pyx_v_obj);
+  __Pyx_GIVEREF(__pyx_v_obj);
+  __Pyx_GOTREF(__pyx_v_self->obj);
+  __Pyx_DECREF(__pyx_v_self->obj);
+  __pyx_v_self->obj = __pyx_v_obj;
+
+  /* "View.MemoryView":347
+ *     def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
+ *         self.obj = obj
+ *         self.flags = flags             # <<<<<<<<<<<<<<
+ *         if type(self) is memoryview or obj is not None:
+ *             __Pyx_GetBuffer(obj, &self.view, flags)
+ */
+  __pyx_v_self->flags = __pyx_v_flags;
+
+  /* "View.MemoryView":348
+ *         self.obj = obj
+ *         self.flags = flags
+ *         if type(self) is memoryview or obj is not None:             # <<<<<<<<<<<<<<
+ *             __Pyx_GetBuffer(obj, &self.view, flags)
+ *             if  self.view.obj == NULL:
+ */
+  __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type));
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_1 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_3 = (__pyx_v_obj != Py_None);
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":349
+ *         self.flags = flags
+ *         if type(self) is memoryview or obj is not None:
+ *             __Pyx_GetBuffer(obj, &self.view, flags)             # <<<<<<<<<<<<<<
+ *             if  self.view.obj == NULL:
+ *                 (<__pyx_buffer *> &self.view).obj = Py_None
+ */
+    __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 349, __pyx_L1_error)
+
+    /* "View.MemoryView":350
+ *         if type(self) is memoryview or obj is not None:
+ *             __Pyx_GetBuffer(obj, &self.view, flags)
+ *             if  self.view.obj == NULL:             # <<<<<<<<<<<<<<
+ *                 (<__pyx_buffer *> &self.view).obj = Py_None
+ *                 Py_INCREF(Py_None)
+ */
+    __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0);
+    if (__pyx_t_1) {
+
+      /* "View.MemoryView":351
+ *             __Pyx_GetBuffer(obj, &self.view, flags)
+ *             if  self.view.obj == NULL:
+ *                 (<__pyx_buffer *> &self.view).obj = Py_None             # <<<<<<<<<<<<<<
+ *                 Py_INCREF(Py_None)
+ * 
+ */
+      ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None;
+
+      /* "View.MemoryView":352
+ *             if  self.view.obj == NULL:
+ *                 (<__pyx_buffer *> &self.view).obj = Py_None
+ *                 Py_INCREF(Py_None)             # <<<<<<<<<<<<<<
+ * 
+ *         global __pyx_memoryview_thread_locks_used
+ */
+      Py_INCREF(Py_None);
+
+      /* "View.MemoryView":350
+ *         if type(self) is memoryview or obj is not None:
+ *             __Pyx_GetBuffer(obj, &self.view, flags)
+ *             if  self.view.obj == NULL:             # <<<<<<<<<<<<<<
+ *                 (<__pyx_buffer *> &self.view).obj = Py_None
+ *                 Py_INCREF(Py_None)
+ */
+    }
+
+    /* "View.MemoryView":348
+ *         self.obj = obj
+ *         self.flags = flags
+ *         if type(self) is memoryview or obj is not None:             # <<<<<<<<<<<<<<
+ *             __Pyx_GetBuffer(obj, &self.view, flags)
+ *             if  self.view.obj == NULL:
+ */
+  }
+
+  /* "View.MemoryView":355
+ * 
+ *         global __pyx_memoryview_thread_locks_used
+ *         if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:             # <<<<<<<<<<<<<<
+ *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ *             __pyx_memoryview_thread_locks_used += 1
+ */
+  __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":356
+ *         global __pyx_memoryview_thread_locks_used
+ *         if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:
+ *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]             # <<<<<<<<<<<<<<
+ *             __pyx_memoryview_thread_locks_used += 1
+ *         if self.lock is NULL:
+ */
+    __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
+
+    /* "View.MemoryView":357
+ *         if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:
+ *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ *             __pyx_memoryview_thread_locks_used += 1             # <<<<<<<<<<<<<<
+ *         if self.lock is NULL:
+ *             self.lock = PyThread_allocate_lock()
+ */
+    __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1);
+
+    /* "View.MemoryView":355
+ * 
+ *         global __pyx_memoryview_thread_locks_used
+ *         if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED:             # <<<<<<<<<<<<<<
+ *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ *             __pyx_memoryview_thread_locks_used += 1
+ */
+  }
+
+  /* "View.MemoryView":358
+ *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ *             __pyx_memoryview_thread_locks_used += 1
+ *         if self.lock is NULL:             # <<<<<<<<<<<<<<
+ *             self.lock = PyThread_allocate_lock()
+ *             if self.lock is NULL:
+ */
+  __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":359
+ *             __pyx_memoryview_thread_locks_used += 1
+ *         if self.lock is NULL:
+ *             self.lock = PyThread_allocate_lock()             # <<<<<<<<<<<<<<
+ *             if self.lock is NULL:
+ *                 raise MemoryError
+ */
+    __pyx_v_self->lock = PyThread_allocate_lock();
+
+    /* "View.MemoryView":360
+ *         if self.lock is NULL:
+ *             self.lock = PyThread_allocate_lock()
+ *             if self.lock is NULL:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError
+ * 
+ */
+    __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0);
+    if (unlikely(__pyx_t_1)) {
+
+      /* "View.MemoryView":361
+ *             self.lock = PyThread_allocate_lock()
+ *             if self.lock is NULL:
+ *                 raise MemoryError             # <<<<<<<<<<<<<<
+ * 
+ *         if flags & PyBUF_FORMAT:
+ */
+      PyErr_NoMemory(); __PYX_ERR(2, 361, __pyx_L1_error)
+
+      /* "View.MemoryView":360
+ *         if self.lock is NULL:
+ *             self.lock = PyThread_allocate_lock()
+ *             if self.lock is NULL:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError
+ * 
+ */
+    }
+
+    /* "View.MemoryView":358
+ *             self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]
+ *             __pyx_memoryview_thread_locks_used += 1
+ *         if self.lock is NULL:             # <<<<<<<<<<<<<<
+ *             self.lock = PyThread_allocate_lock()
+ *             if self.lock is NULL:
+ */
+  }
+
+  /* "View.MemoryView":363
+ *                 raise MemoryError
+ * 
+ *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
+ *             self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
+ *         else:
+ */
+  __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":364
+ * 
+ *         if flags & PyBUF_FORMAT:
+ *             self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')             # <<<<<<<<<<<<<<
+ *         else:
+ *             self.dtype_is_object = dtype_is_object
+ */
+    __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L11_bool_binop_done;
+    }
+    __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0);
+    __pyx_t_1 = __pyx_t_2;
+    __pyx_L11_bool_binop_done:;
+    __pyx_v_self->dtype_is_object = __pyx_t_1;
+
+    /* "View.MemoryView":363
+ *                 raise MemoryError
+ * 
+ *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
+ *             self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
+ *         else:
+ */
+    goto __pyx_L10;
+  }
+
+  /* "View.MemoryView":366
+ *             self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0')
+ *         else:
+ *             self.dtype_is_object = dtype_is_object             # <<<<<<<<<<<<<<
+ * 
+ *         self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(
+ */
+  /*else*/ {
+    __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object;
+  }
+  __pyx_L10:;
+
+  /* "View.MemoryView":368
+ *             self.dtype_is_object = dtype_is_object
+ * 
+ *         self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(             # <<<<<<<<<<<<<<
+ *                    &self.acquisition_count[0], sizeof(__pyx_atomic_int))
+ *         self.typeinfo = NULL
+ */
+  __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int))));
+
+  /* "View.MemoryView":370
+ *         self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(
+ *                    &self.acquisition_count[0], sizeof(__pyx_atomic_int))
+ *         self.typeinfo = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(memoryview self):
+ */
+  __pyx_v_self->typeinfo = NULL;
+
+  /* "View.MemoryView":345
+ *     cdef __Pyx_TypeInfo *typeinfo
+ * 
+ *     def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):             # <<<<<<<<<<<<<<
+ *         self.obj = obj
+ *         self.flags = flags
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":372
+ *         self.typeinfo = NULL
+ * 
+ *     def __dealloc__(memoryview self):             # <<<<<<<<<<<<<<
+ *         if self.obj is not None:
+ *             __Pyx_ReleaseBuffer(&self.view)
+ */
+
+/* Python wrapper */
+static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  int __pyx_v_i;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyThread_type_lock __pyx_t_6;
+  PyThread_type_lock __pyx_t_7;
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "View.MemoryView":373
+ * 
+ *     def __dealloc__(memoryview self):
+ *         if self.obj is not None:             # <<<<<<<<<<<<<<
+ *             __Pyx_ReleaseBuffer(&self.view)
+ *         elif (<__pyx_buffer *> &self.view).obj == Py_None:
+ */
+  __pyx_t_1 = (__pyx_v_self->obj != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":374
+ *     def __dealloc__(memoryview self):
+ *         if self.obj is not None:
+ *             __Pyx_ReleaseBuffer(&self.view)             # <<<<<<<<<<<<<<
+ *         elif (<__pyx_buffer *> &self.view).obj == Py_None:
+ * 
+ */
+    __Pyx_ReleaseBuffer((&__pyx_v_self->view));
+
+    /* "View.MemoryView":373
+ * 
+ *     def __dealloc__(memoryview self):
+ *         if self.obj is not None:             # <<<<<<<<<<<<<<
+ *             __Pyx_ReleaseBuffer(&self.view)
+ *         elif (<__pyx_buffer *> &self.view).obj == Py_None:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":375
+ *         if self.obj is not None:
+ *             __Pyx_ReleaseBuffer(&self.view)
+ *         elif (<__pyx_buffer *> &self.view).obj == Py_None:             # <<<<<<<<<<<<<<
+ * 
+ *             (<__pyx_buffer *> &self.view).obj = NULL
+ */
+  __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":377
+ *         elif (<__pyx_buffer *> &self.view).obj == Py_None:
+ * 
+ *             (<__pyx_buffer *> &self.view).obj = NULL             # <<<<<<<<<<<<<<
+ *             Py_DECREF(Py_None)
+ * 
+ */
+    ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL;
+
+    /* "View.MemoryView":378
+ * 
+ *             (<__pyx_buffer *> &self.view).obj = NULL
+ *             Py_DECREF(Py_None)             # <<<<<<<<<<<<<<
+ * 
+ *         cdef int i
+ */
+    Py_DECREF(Py_None);
+
+    /* "View.MemoryView":375
+ *         if self.obj is not None:
+ *             __Pyx_ReleaseBuffer(&self.view)
+ *         elif (<__pyx_buffer *> &self.view).obj == Py_None:             # <<<<<<<<<<<<<<
+ * 
+ *             (<__pyx_buffer *> &self.view).obj = NULL
+ */
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":382
+ *         cdef int i
+ *         global __pyx_memoryview_thread_locks_used
+ *         if self.lock != NULL:             # <<<<<<<<<<<<<<
+ *             for i in range(__pyx_memoryview_thread_locks_used):
+ *                 if __pyx_memoryview_thread_locks[i] is self.lock:
+ */
+  __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":383
+ *         global __pyx_memoryview_thread_locks_used
+ *         if self.lock != NULL:
+ *             for i in range(__pyx_memoryview_thread_locks_used):             # <<<<<<<<<<<<<<
+ *                 if __pyx_memoryview_thread_locks[i] is self.lock:
+ *                     __pyx_memoryview_thread_locks_used -= 1
+ */
+    __pyx_t_3 = __pyx_memoryview_thread_locks_used;
+    __pyx_t_4 = __pyx_t_3;
+    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+      __pyx_v_i = __pyx_t_5;
+
+      /* "View.MemoryView":384
+ *         if self.lock != NULL:
+ *             for i in range(__pyx_memoryview_thread_locks_used):
+ *                 if __pyx_memoryview_thread_locks[i] is self.lock:             # <<<<<<<<<<<<<<
+ *                     __pyx_memoryview_thread_locks_used -= 1
+ *                     if i != __pyx_memoryview_thread_locks_used:
+ */
+      __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":385
+ *             for i in range(__pyx_memoryview_thread_locks_used):
+ *                 if __pyx_memoryview_thread_locks[i] is self.lock:
+ *                     __pyx_memoryview_thread_locks_used -= 1             # <<<<<<<<<<<<<<
+ *                     if i != __pyx_memoryview_thread_locks_used:
+ *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ */
+        __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1);
+
+        /* "View.MemoryView":386
+ *                 if __pyx_memoryview_thread_locks[i] is self.lock:
+ *                     __pyx_memoryview_thread_locks_used -= 1
+ *                     if i != __pyx_memoryview_thread_locks_used:             # <<<<<<<<<<<<<<
+ *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
+ */
+        __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0);
+        if (__pyx_t_2) {
+
+          /* "View.MemoryView":388
+ *                     if i != __pyx_memoryview_thread_locks_used:
+ *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])             # <<<<<<<<<<<<<<
+ *                     break
+ *             else:
+ */
+          __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]);
+          __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]);
+
+          /* "View.MemoryView":387
+ *                     __pyx_memoryview_thread_locks_used -= 1
+ *                     if i != __pyx_memoryview_thread_locks_used:
+ *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (             # <<<<<<<<<<<<<<
+ *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
+ *                     break
+ */
+          (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6;
+          (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7;
+
+          /* "View.MemoryView":386
+ *                 if __pyx_memoryview_thread_locks[i] is self.lock:
+ *                     __pyx_memoryview_thread_locks_used -= 1
+ *                     if i != __pyx_memoryview_thread_locks_used:             # <<<<<<<<<<<<<<
+ *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
+ */
+        }
+
+        /* "View.MemoryView":389
+ *                         __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = (
+ *                             __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i])
+ *                     break             # <<<<<<<<<<<<<<
+ *             else:
+ *                 PyThread_free_lock(self.lock)
+ */
+        goto __pyx_L6_break;
+
+        /* "View.MemoryView":384
+ *         if self.lock != NULL:
+ *             for i in range(__pyx_memoryview_thread_locks_used):
+ *                 if __pyx_memoryview_thread_locks[i] is self.lock:             # <<<<<<<<<<<<<<
+ *                     __pyx_memoryview_thread_locks_used -= 1
+ *                     if i != __pyx_memoryview_thread_locks_used:
+ */
+      }
+    }
+    /*else*/ {
+
+      /* "View.MemoryView":391
+ *                     break
+ *             else:
+ *                 PyThread_free_lock(self.lock)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef char *get_item_pointer(memoryview self, object index) except NULL:
+ */
+      PyThread_free_lock(__pyx_v_self->lock);
+    }
+    __pyx_L6_break:;
+
+    /* "View.MemoryView":382
+ *         cdef int i
+ *         global __pyx_memoryview_thread_locks_used
+ *         if self.lock != NULL:             # <<<<<<<<<<<<<<
+ *             for i in range(__pyx_memoryview_thread_locks_used):
+ *                 if __pyx_memoryview_thread_locks[i] is self.lock:
+ */
+  }
+
+  /* "View.MemoryView":372
+ *         self.typeinfo = NULL
+ * 
+ *     def __dealloc__(memoryview self):             # <<<<<<<<<<<<<<
+ *         if self.obj is not None:
+ *             __Pyx_ReleaseBuffer(&self.view)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":393
+ *                 PyThread_free_lock(self.lock)
+ * 
+ *     cdef char *get_item_pointer(memoryview self, object index) except NULL:             # <<<<<<<<<<<<<<
+ *         cdef Py_ssize_t dim
+ *         cdef char *itemp =  self.view.buf
+ */
+
+static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
+  Py_ssize_t __pyx_v_dim;
+  char *__pyx_v_itemp;
+  PyObject *__pyx_v_idx = NULL;
+  char *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  Py_ssize_t __pyx_t_6;
+  char *__pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_item_pointer", 0);
+
+  /* "View.MemoryView":395
+ *     cdef char *get_item_pointer(memoryview self, object index) except NULL:
+ *         cdef Py_ssize_t dim
+ *         cdef char *itemp =  self.view.buf             # <<<<<<<<<<<<<<
+ * 
+ *         for dim, idx in enumerate(index):
+ */
+  __pyx_v_itemp = ((char *)__pyx_v_self->view.buf);
+
+  /* "View.MemoryView":397
+ *         cdef char *itemp =  self.view.buf
+ * 
+ *         for dim, idx in enumerate(index):             # <<<<<<<<<<<<<<
+ *             itemp = pybuffer_index(&self.view, itemp, idx, dim)
+ * 
+ */
+  __pyx_t_1 = 0;
+  if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) {
+    __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 397, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 397, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 397, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 397, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 397, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 397, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(2, 397, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __pyx_v_dim = __pyx_t_1;
+    __pyx_t_1 = (__pyx_t_1 + 1);
+
+    /* "View.MemoryView":398
+ * 
+ *         for dim, idx in enumerate(index):
+ *             itemp = pybuffer_index(&self.view, itemp, idx, dim)             # <<<<<<<<<<<<<<
+ * 
+ *         return itemp
+ */
+    __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 398, __pyx_L1_error)
+    __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(2, 398, __pyx_L1_error)
+    __pyx_v_itemp = __pyx_t_7;
+
+    /* "View.MemoryView":397
+ *         cdef char *itemp =  self.view.buf
+ * 
+ *         for dim, idx in enumerate(index):             # <<<<<<<<<<<<<<
+ *             itemp = pybuffer_index(&self.view, itemp, idx, dim)
+ * 
+ */
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "View.MemoryView":400
+ *             itemp = pybuffer_index(&self.view, itemp, idx, dim)
+ * 
+ *         return itemp             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_itemp;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":393
+ *                 PyThread_free_lock(self.lock)
+ * 
+ *     cdef char *get_item_pointer(memoryview self, object index) except NULL:             # <<<<<<<<<<<<<<
+ *         cdef Py_ssize_t dim
+ *         cdef char *itemp =  self.view.buf
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_idx);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":403
+ * 
+ * 
+ *     def __getitem__(memoryview self, object index):             # <<<<<<<<<<<<<<
+ *         if index is Ellipsis:
+ *             return self
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/
+static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) {
+  PyObject *__pyx_v_have_slices = NULL;
+  PyObject *__pyx_v_indices = NULL;
+  char *__pyx_v_itemp;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  char *__pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
+
+  /* "View.MemoryView":404
+ * 
+ *     def __getitem__(memoryview self, object index):
+ *         if index is Ellipsis:             # <<<<<<<<<<<<<<
+ *             return self
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":405
+ *     def __getitem__(memoryview self, object index):
+ *         if index is Ellipsis:
+ *             return self             # <<<<<<<<<<<<<<
+ * 
+ *         have_slices, indices = _unellipsify(index, self.view.ndim)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __pyx_r = ((PyObject *)__pyx_v_self);
+    goto __pyx_L0;
+
+    /* "View.MemoryView":404
+ * 
+ *     def __getitem__(memoryview self, object index):
+ *         if index is Ellipsis:             # <<<<<<<<<<<<<<
+ *             return self
+ * 
+ */
+  }
+
+  /* "View.MemoryView":407
+ *             return self
+ * 
+ *         have_slices, indices = _unellipsify(index, self.view.ndim)             # <<<<<<<<<<<<<<
+ * 
+ *         cdef char *itemp
+ */
+  __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (likely(__pyx_t_3 != Py_None)) {
+    PyObject* sequence = __pyx_t_3;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(2, 407, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
+    __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); 
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_5);
+    #else
+    __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 407, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 407, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    #endif
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 407, __pyx_L1_error)
+  }
+  __pyx_v_have_slices = __pyx_t_4;
+  __pyx_t_4 = 0;
+  __pyx_v_indices = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "View.MemoryView":410
+ * 
+ *         cdef char *itemp
+ *         if have_slices:             # <<<<<<<<<<<<<<
+ *             return memview_slice(self, indices)
+ *         else:
+ */
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 410, __pyx_L1_error)
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":411
+ *         cdef char *itemp
+ *         if have_slices:
+ *             return memview_slice(self, indices)             # <<<<<<<<<<<<<<
+ *         else:
+ *             itemp = self.get_item_pointer(indices)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 411, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "View.MemoryView":410
+ * 
+ *         cdef char *itemp
+ *         if have_slices:             # <<<<<<<<<<<<<<
+ *             return memview_slice(self, indices)
+ *         else:
+ */
+  }
+
+  /* "View.MemoryView":413
+ *             return memview_slice(self, indices)
+ *         else:
+ *             itemp = self.get_item_pointer(indices)             # <<<<<<<<<<<<<<
+ *             return self.convert_item_to_object(itemp)
+ * 
+ */
+  /*else*/ {
+    __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(2, 413, __pyx_L1_error)
+    __pyx_v_itemp = __pyx_t_6;
+
+    /* "View.MemoryView":414
+ *         else:
+ *             itemp = self.get_item_pointer(indices)
+ *             return self.convert_item_to_object(itemp)             # <<<<<<<<<<<<<<
+ * 
+ *     def __setitem__(memoryview self, object index, object value):
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 414, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "View.MemoryView":403
+ * 
+ * 
+ *     def __getitem__(memoryview self, object index):             # <<<<<<<<<<<<<<
+ *         if index is Ellipsis:
+ *             return self
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_have_slices);
+  __Pyx_XDECREF(__pyx_v_indices);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":416
+ *             return self.convert_item_to_object(itemp)
+ * 
+ *     def __setitem__(memoryview self, object index, object value):             # <<<<<<<<<<<<<<
+ *         if self.view.readonly:
+ *             raise TypeError("Cannot assign to read-only memoryview")
+ */
+
+/* Python wrapper */
+static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/
+static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
+  PyObject *__pyx_v_have_slices = NULL;
+  PyObject *__pyx_v_obj = NULL;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__setitem__", 0);
+  __Pyx_INCREF(__pyx_v_index);
+
+  /* "View.MemoryView":417
+ * 
+ *     def __setitem__(memoryview self, object index, object value):
+ *         if self.view.readonly:             # <<<<<<<<<<<<<<
+ *             raise TypeError("Cannot assign to read-only memoryview")
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->view.readonly != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "View.MemoryView":418
+ *     def __setitem__(memoryview self, object index, object value):
+ *         if self.view.readonly:
+ *             raise TypeError("Cannot assign to read-only memoryview")             # <<<<<<<<<<<<<<
+ * 
+ *         have_slices, index = _unellipsify(index, self.view.ndim)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 418, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(2, 418, __pyx_L1_error)
+
+    /* "View.MemoryView":417
+ * 
+ *     def __setitem__(memoryview self, object index, object value):
+ *         if self.view.readonly:             # <<<<<<<<<<<<<<
+ *             raise TypeError("Cannot assign to read-only memoryview")
+ * 
+ */
+  }
+
+  /* "View.MemoryView":420
+ *             raise TypeError("Cannot assign to read-only memoryview")
+ * 
+ *         have_slices, index = _unellipsify(index, self.view.ndim)             # <<<<<<<<<<<<<<
+ * 
+ *         if have_slices:
+ */
+  __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 420, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (likely(__pyx_t_2 != Py_None)) {
+    PyObject* sequence = __pyx_t_2;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 2)) {
+      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(2, 420, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
+    __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_4);
+    #else
+    __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    #endif
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 420, __pyx_L1_error)
+  }
+  __pyx_v_have_slices = __pyx_t_3;
+  __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "View.MemoryView":422
+ *         have_slices, index = _unellipsify(index, self.view.ndim)
+ * 
+ *         if have_slices:             # <<<<<<<<<<<<<<
+ *             obj = self.is_slice(value)
+ *             if obj:
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 422, __pyx_L1_error)
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":423
+ * 
+ *         if have_slices:
+ *             obj = self.is_slice(value)             # <<<<<<<<<<<<<<
+ *             if obj:
+ *                 self.setitem_slice_assignment(self[index], obj)
+ */
+    __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 423, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_obj = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "View.MemoryView":424
+ *         if have_slices:
+ *             obj = self.is_slice(value)
+ *             if obj:             # <<<<<<<<<<<<<<
+ *                 self.setitem_slice_assignment(self[index], obj)
+ *             else:
+ */
+    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 424, __pyx_L1_error)
+    if (__pyx_t_1) {
+
+      /* "View.MemoryView":425
+ *             obj = self.is_slice(value)
+ *             if obj:
+ *                 self.setitem_slice_assignment(self[index], obj)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self.setitem_slice_assign_scalar(self[index], value)
+ */
+      __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 425, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 425, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "View.MemoryView":424
+ *         if have_slices:
+ *             obj = self.is_slice(value)
+ *             if obj:             # <<<<<<<<<<<<<<
+ *                 self.setitem_slice_assignment(self[index], obj)
+ *             else:
+ */
+      goto __pyx_L5;
+    }
+
+    /* "View.MemoryView":427
+ *                 self.setitem_slice_assignment(self[index], obj)
+ *             else:
+ *                 self.setitem_slice_assign_scalar(self[index], value)             # <<<<<<<<<<<<<<
+ *         else:
+ *             self.setitem_indexed(index, value)
+ */
+    /*else*/ {
+      __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 427, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(2, 427, __pyx_L1_error)
+      __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 427, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+    __pyx_L5:;
+
+    /* "View.MemoryView":422
+ *         have_slices, index = _unellipsify(index, self.view.ndim)
+ * 
+ *         if have_slices:             # <<<<<<<<<<<<<<
+ *             obj = self.is_slice(value)
+ *             if obj:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "View.MemoryView":429
+ *                 self.setitem_slice_assign_scalar(self[index], value)
+ *         else:
+ *             self.setitem_indexed(index, value)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef is_slice(self, obj):
+ */
+  /*else*/ {
+    __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 429, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __pyx_L4:;
+
+  /* "View.MemoryView":416
+ *             return self.convert_item_to_object(itemp)
+ * 
+ *     def __setitem__(memoryview self, object index, object value):             # <<<<<<<<<<<<<<
+ *         if self.view.readonly:
+ *             raise TypeError("Cannot assign to read-only memoryview")
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_have_slices);
+  __Pyx_XDECREF(__pyx_v_obj);
+  __Pyx_XDECREF(__pyx_v_index);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":431
+ *             self.setitem_indexed(index, value)
+ * 
+ *     cdef is_slice(self, obj):             # <<<<<<<<<<<<<<
+ *         if not isinstance(obj, memoryview):
+ *             try:
+ */
+
+static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("is_slice", 0);
+  __Pyx_INCREF(__pyx_v_obj);
+
+  /* "View.MemoryView":432
+ * 
+ *     cdef is_slice(self, obj):
+ *         if not isinstance(obj, memoryview):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ */
+  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); 
+  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":433
+ *     cdef is_slice(self, obj):
+ *         if not isinstance(obj, memoryview):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ *                                  self.dtype_is_object)
+ */
+    {
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_3);
+      __Pyx_XGOTREF(__pyx_t_4);
+      __Pyx_XGOTREF(__pyx_t_5);
+      /*try:*/ {
+
+        /* "View.MemoryView":434
+ *         if not isinstance(obj, memoryview):
+ *             try:
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,             # <<<<<<<<<<<<<<
+ *                                  self.dtype_is_object)
+ *             except TypeError:
+ */
+        __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 434, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_6);
+
+        /* "View.MemoryView":435
+ *             try:
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ *                                  self.dtype_is_object)             # <<<<<<<<<<<<<<
+ *             except TypeError:
+ *                 return None
+ */
+        __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 435, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_7);
+
+        /* "View.MemoryView":434
+ *         if not isinstance(obj, memoryview):
+ *             try:
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,             # <<<<<<<<<<<<<<
+ *                                  self.dtype_is_object)
+ *             except TypeError:
+ */
+        __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 434, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_INCREF(__pyx_v_obj);
+        __Pyx_GIVEREF(__pyx_v_obj);
+        PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj);
+        __Pyx_GIVEREF(__pyx_t_6);
+        PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6);
+        __Pyx_GIVEREF(__pyx_t_7);
+        PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7);
+        __pyx_t_6 = 0;
+        __pyx_t_7 = 0;
+        __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 434, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7);
+        __pyx_t_7 = 0;
+
+        /* "View.MemoryView":433
+ *     cdef is_slice(self, obj):
+ *         if not isinstance(obj, memoryview):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ *                                  self.dtype_is_object)
+ */
+      }
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      goto __pyx_L9_try_end;
+      __pyx_L4_error:;
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+      /* "View.MemoryView":436
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ *                                  self.dtype_is_object)
+ *             except TypeError:             # <<<<<<<<<<<<<<
+ *                 return None
+ * 
+ */
+      __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
+      if (__pyx_t_9) {
+        __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(2, 436, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GOTREF(__pyx_t_6);
+
+        /* "View.MemoryView":437
+ *                                  self.dtype_is_object)
+ *             except TypeError:
+ *                 return None             # <<<<<<<<<<<<<<
+ * 
+ *         return obj
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        goto __pyx_L7_except_return;
+      }
+      goto __pyx_L6_except_error;
+      __pyx_L6_except_error:;
+
+      /* "View.MemoryView":433
+ *     cdef is_slice(self, obj):
+ *         if not isinstance(obj, memoryview):
+ *             try:             # <<<<<<<<<<<<<<
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ *                                  self.dtype_is_object)
+ */
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+      goto __pyx_L1_error;
+      __pyx_L7_except_return:;
+      __Pyx_XGIVEREF(__pyx_t_3);
+      __Pyx_XGIVEREF(__pyx_t_4);
+      __Pyx_XGIVEREF(__pyx_t_5);
+      __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+      goto __pyx_L0;
+      __pyx_L9_try_end:;
+    }
+
+    /* "View.MemoryView":432
+ * 
+ *     cdef is_slice(self, obj):
+ *         if not isinstance(obj, memoryview):             # <<<<<<<<<<<<<<
+ *             try:
+ *                 obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS,
+ */
+  }
+
+  /* "View.MemoryView":439
+ *                 return None
+ * 
+ *         return obj             # <<<<<<<<<<<<<<
+ * 
+ *     cdef setitem_slice_assignment(self, dst, src):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_obj);
+  __pyx_r = __pyx_v_obj;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":431
+ *             self.setitem_indexed(index, value)
+ * 
+ *     cdef is_slice(self, obj):             # <<<<<<<<<<<<<<
+ *         if not isinstance(obj, memoryview):
+ *             try:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_obj);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":441
+ *         return obj
+ * 
+ *     cdef setitem_slice_assignment(self, dst, src):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice dst_slice
+ *         cdef __Pyx_memviewslice src_slice
+ */
+
+static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) {
+  __Pyx_memviewslice __pyx_v_dst_slice;
+  __Pyx_memviewslice __pyx_v_src_slice;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_memviewslice *__pyx_t_1;
+  __Pyx_memviewslice *__pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("setitem_slice_assignment", 0);
+
+  /* "View.MemoryView":445
+ *         cdef __Pyx_memviewslice src_slice
+ * 
+ *         memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],             # <<<<<<<<<<<<<<
+ *                                  get_slice_from_memview(dst, &dst_slice)[0],
+ *                                  src.ndim, dst.ndim, self.dtype_is_object)
+ */
+  if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(2, 445, __pyx_L1_error)
+  __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 445, __pyx_L1_error)
+
+  /* "View.MemoryView":446
+ * 
+ *         memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],
+ *                                  get_slice_from_memview(dst, &dst_slice)[0],             # <<<<<<<<<<<<<<
+ *                                  src.ndim, dst.ndim, self.dtype_is_object)
+ * 
+ */
+  if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(2, 446, __pyx_L1_error)
+  __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 446, __pyx_L1_error)
+
+  /* "View.MemoryView":447
+ *         memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],
+ *                                  get_slice_from_memview(dst, &dst_slice)[0],
+ *                                  src.ndim, dst.ndim, self.dtype_is_object)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef setitem_slice_assign_scalar(self, memoryview dst, value):
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 447, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 447, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 447, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 447, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "View.MemoryView":445
+ *         cdef __Pyx_memviewslice src_slice
+ * 
+ *         memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],             # <<<<<<<<<<<<<<
+ *                                  get_slice_from_memview(dst, &dst_slice)[0],
+ *                                  src.ndim, dst.ndim, self.dtype_is_object)
+ */
+  __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 445, __pyx_L1_error)
+
+  /* "View.MemoryView":441
+ *         return obj
+ * 
+ *     cdef setitem_slice_assignment(self, dst, src):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice dst_slice
+ *         cdef __Pyx_memviewslice src_slice
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":449
+ *                                  src.ndim, dst.ndim, self.dtype_is_object)
+ * 
+ *     cdef setitem_slice_assign_scalar(self, memoryview dst, value):             # <<<<<<<<<<<<<<
+ *         cdef int array[128]
+ *         cdef void *tmp = NULL
+ */
+
+static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) {
+  int __pyx_v_array[0x80];
+  void *__pyx_v_tmp;
+  void *__pyx_v_item;
+  __Pyx_memviewslice *__pyx_v_dst_slice;
+  __Pyx_memviewslice __pyx_v_tmp_slice;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_memviewslice *__pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  char const *__pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0);
+
+  /* "View.MemoryView":451
+ *     cdef setitem_slice_assign_scalar(self, memoryview dst, value):
+ *         cdef int array[128]
+ *         cdef void *tmp = NULL             # <<<<<<<<<<<<<<
+ *         cdef void *item
+ * 
+ */
+  __pyx_v_tmp = NULL;
+
+  /* "View.MemoryView":456
+ *         cdef __Pyx_memviewslice *dst_slice
+ *         cdef __Pyx_memviewslice tmp_slice
+ *         dst_slice = get_slice_from_memview(dst, &tmp_slice)             # <<<<<<<<<<<<<<
+ * 
+ *         if self.view.itemsize > sizeof(array):
+ */
+  __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 456, __pyx_L1_error)
+  __pyx_v_dst_slice = __pyx_t_1;
+
+  /* "View.MemoryView":458
+ *         dst_slice = get_slice_from_memview(dst, &tmp_slice)
+ * 
+ *         if self.view.itemsize > sizeof(array):             # <<<<<<<<<<<<<<
+ *             tmp = PyMem_Malloc(self.view.itemsize)
+ *             if tmp == NULL:
+ */
+  __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":459
+ * 
+ *         if self.view.itemsize > sizeof(array):
+ *             tmp = PyMem_Malloc(self.view.itemsize)             # <<<<<<<<<<<<<<
+ *             if tmp == NULL:
+ *                 raise MemoryError
+ */
+    __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize);
+
+    /* "View.MemoryView":460
+ *         if self.view.itemsize > sizeof(array):
+ *             tmp = PyMem_Malloc(self.view.itemsize)
+ *             if tmp == NULL:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError
+ *             item = tmp
+ */
+    __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "View.MemoryView":461
+ *             tmp = PyMem_Malloc(self.view.itemsize)
+ *             if tmp == NULL:
+ *                 raise MemoryError             # <<<<<<<<<<<<<<
+ *             item = tmp
+ *         else:
+ */
+      PyErr_NoMemory(); __PYX_ERR(2, 461, __pyx_L1_error)
+
+      /* "View.MemoryView":460
+ *         if self.view.itemsize > sizeof(array):
+ *             tmp = PyMem_Malloc(self.view.itemsize)
+ *             if tmp == NULL:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError
+ *             item = tmp
+ */
+    }
+
+    /* "View.MemoryView":462
+ *             if tmp == NULL:
+ *                 raise MemoryError
+ *             item = tmp             # <<<<<<<<<<<<<<
+ *         else:
+ *             item =  array
+ */
+    __pyx_v_item = __pyx_v_tmp;
+
+    /* "View.MemoryView":458
+ *         dst_slice = get_slice_from_memview(dst, &tmp_slice)
+ * 
+ *         if self.view.itemsize > sizeof(array):             # <<<<<<<<<<<<<<
+ *             tmp = PyMem_Malloc(self.view.itemsize)
+ *             if tmp == NULL:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":464
+ *             item = tmp
+ *         else:
+ *             item =  array             # <<<<<<<<<<<<<<
+ * 
+ *         try:
+ */
+  /*else*/ {
+    __pyx_v_item = ((void *)__pyx_v_array);
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":466
+ *             item =  array
+ * 
+ *         try:             # <<<<<<<<<<<<<<
+ *             if self.dtype_is_object:
+ *                 ( item)[0] =  value
+ */
+  /*try:*/ {
+
+    /* "View.MemoryView":467
+ * 
+ *         try:
+ *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
+ *                 ( item)[0] =  value
+ *             else:
+ */
+    __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":468
+ *         try:
+ *             if self.dtype_is_object:
+ *                 ( item)[0] =  value             # <<<<<<<<<<<<<<
+ *             else:
+ *                 self.assign_item_from_object( item, value)
+ */
+      (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value);
+
+      /* "View.MemoryView":467
+ * 
+ *         try:
+ *             if self.dtype_is_object:             # <<<<<<<<<<<<<<
+ *                 ( item)[0] =  value
+ *             else:
+ */
+      goto __pyx_L8;
+    }
+
+    /* "View.MemoryView":470
+ *                 ( item)[0] =  value
+ *             else:
+ *                 self.assign_item_from_object( item, value)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    /*else*/ {
+      __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 470, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+    __pyx_L8:;
+
+    /* "View.MemoryView":474
+ * 
+ * 
+ *             if self.view.suboffsets != NULL:             # <<<<<<<<<<<<<<
+ *                 assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
+ *             slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
+ */
+    __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":475
+ * 
+ *             if self.view.suboffsets != NULL:
+ *                 assert_direct_dimensions(self.view.suboffsets, self.view.ndim)             # <<<<<<<<<<<<<<
+ *             slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
+ *                                 item, self.dtype_is_object)
+ */
+      __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 475, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+      /* "View.MemoryView":474
+ * 
+ * 
+ *             if self.view.suboffsets != NULL:             # <<<<<<<<<<<<<<
+ *                 assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
+ *             slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
+ */
+    }
+
+    /* "View.MemoryView":476
+ *             if self.view.suboffsets != NULL:
+ *                 assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
+ *             slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,             # <<<<<<<<<<<<<<
+ *                                 item, self.dtype_is_object)
+ *         finally:
+ */
+    __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object);
+  }
+
+  /* "View.MemoryView":479
+ *                                 item, self.dtype_is_object)
+ *         finally:
+ *             PyMem_Free(tmp)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef setitem_indexed(self, index, value):
+ */
+  /*finally:*/ {
+    /*normal exit:*/{
+      PyMem_Free(__pyx_v_tmp);
+      goto __pyx_L7;
+    }
+    __pyx_L6_error:;
+    /*exception exit:*/{
+      __Pyx_PyThreadState_declare
+      __Pyx_PyThreadState_assign
+      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_9);
+      __Pyx_XGOTREF(__pyx_t_10);
+      __Pyx_XGOTREF(__pyx_t_11);
+      __Pyx_XGOTREF(__pyx_t_12);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
+      {
+        PyMem_Free(__pyx_v_tmp);
+      }
+      if (PY_MAJOR_VERSION >= 3) {
+        __Pyx_XGIVEREF(__pyx_t_10);
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
+      }
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+      __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6;
+      goto __pyx_L1_error;
+    }
+    __pyx_L7:;
+  }
+
+  /* "View.MemoryView":449
+ *                                  src.ndim, dst.ndim, self.dtype_is_object)
+ * 
+ *     cdef setitem_slice_assign_scalar(self, memoryview dst, value):             # <<<<<<<<<<<<<<
+ *         cdef int array[128]
+ *         cdef void *tmp = NULL
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":481
+ *             PyMem_Free(tmp)
+ * 
+ *     cdef setitem_indexed(self, index, value):             # <<<<<<<<<<<<<<
+ *         cdef char *itemp = self.get_item_pointer(index)
+ *         self.assign_item_from_object(itemp, value)
+ */
+
+static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) {
+  char *__pyx_v_itemp;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  char *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("setitem_indexed", 0);
+
+  /* "View.MemoryView":482
+ * 
+ *     cdef setitem_indexed(self, index, value):
+ *         cdef char *itemp = self.get_item_pointer(index)             # <<<<<<<<<<<<<<
+ *         self.assign_item_from_object(itemp, value)
+ * 
+ */
+  __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(2, 482, __pyx_L1_error)
+  __pyx_v_itemp = __pyx_t_1;
+
+  /* "View.MemoryView":483
+ *     cdef setitem_indexed(self, index, value):
+ *         cdef char *itemp = self.get_item_pointer(index)
+ *         self.assign_item_from_object(itemp, value)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef convert_item_to_object(self, char *itemp):
+ */
+  __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 483, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "View.MemoryView":481
+ *             PyMem_Free(tmp)
+ * 
+ *     cdef setitem_indexed(self, index, value):             # <<<<<<<<<<<<<<
+ *         cdef char *itemp = self.get_item_pointer(index)
+ *         self.assign_item_from_object(itemp, value)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":485
+ *         self.assign_item_from_object(itemp, value)
+ * 
+ *     cdef convert_item_to_object(self, char *itemp):             # <<<<<<<<<<<<<<
+ *         """Only used if instantiated manually by the user, or if Cython doesn't
+ *         know how to convert the type"""
+ */
+
+static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) {
+  PyObject *__pyx_v_struct = NULL;
+  PyObject *__pyx_v_bytesitem = 0;
+  PyObject *__pyx_v_result = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  size_t __pyx_t_10;
+  int __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("convert_item_to_object", 0);
+
+  /* "View.MemoryView":488
+ *         """Only used if instantiated manually by the user, or if Cython doesn't
+ *         know how to convert the type"""
+ *         import struct             # <<<<<<<<<<<<<<
+ *         cdef bytes bytesitem
+ * 
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 488, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_struct = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":491
+ *         cdef bytes bytesitem
+ * 
+ *         bytesitem = itemp[:self.view.itemsize]             # <<<<<<<<<<<<<<
+ *         try:
+ *             result = struct.unpack(self.view.format, bytesitem)
+ */
+  __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 491, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_bytesitem = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":492
+ * 
+ *         bytesitem = itemp[:self.view.itemsize]
+ *         try:             # <<<<<<<<<<<<<<
+ *             result = struct.unpack(self.view.format, bytesitem)
+ *         except struct.error:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    /*try:*/ {
+
+      /* "View.MemoryView":493
+ *         bytesitem = itemp[:self.view.itemsize]
+ *         try:
+ *             result = struct.unpack(self.view.format, bytesitem)             # <<<<<<<<<<<<<<
+ *         except struct.error:
+ *             raise ValueError("Unable to convert item to object")
+ */
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 493, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 493, __pyx_L3_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_7 = NULL;
+      __pyx_t_8 = 0;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_5, function);
+          __pyx_t_8 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 493, __pyx_L3_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 493, __pyx_L3_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 493, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (__pyx_t_7) {
+          __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        }
+        __Pyx_GIVEREF(__pyx_t_6);
+        PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6);
+        __Pyx_INCREF(__pyx_v_bytesitem);
+        __Pyx_GIVEREF(__pyx_v_bytesitem);
+        PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem);
+        __pyx_t_6 = 0;
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 493, __pyx_L3_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_v_result = __pyx_t_1;
+      __pyx_t_1 = 0;
+
+      /* "View.MemoryView":492
+ * 
+ *         bytesitem = itemp[:self.view.itemsize]
+ *         try:             # <<<<<<<<<<<<<<
+ *             result = struct.unpack(self.view.format, bytesitem)
+ *         except struct.error:
+ */
+    }
+
+    /* "View.MemoryView":497
+ *             raise ValueError("Unable to convert item to object")
+ *         else:
+ *             if len(self.view.format) == 1:             # <<<<<<<<<<<<<<
+ *                 return result[0]
+ *             return result
+ */
+    /*else:*/ {
+      __pyx_t_10 = strlen(__pyx_v_self->view.format); 
+      __pyx_t_11 = ((__pyx_t_10 == 1) != 0);
+      if (__pyx_t_11) {
+
+        /* "View.MemoryView":498
+ *         else:
+ *             if len(self.view.format) == 1:
+ *                 return result[0]             # <<<<<<<<<<<<<<
+ *             return result
+ * 
+ */
+        __Pyx_XDECREF(__pyx_r);
+        __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 498, __pyx_L5_except_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_r = __pyx_t_1;
+        __pyx_t_1 = 0;
+        goto __pyx_L6_except_return;
+
+        /* "View.MemoryView":497
+ *             raise ValueError("Unable to convert item to object")
+ *         else:
+ *             if len(self.view.format) == 1:             # <<<<<<<<<<<<<<
+ *                 return result[0]
+ *             return result
+ */
+      }
+
+      /* "View.MemoryView":499
+ *             if len(self.view.format) == 1:
+ *                 return result[0]
+ *             return result             # <<<<<<<<<<<<<<
+ * 
+ *     cdef assign_item_from_object(self, char *itemp, object value):
+ */
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(__pyx_v_result);
+      __pyx_r = __pyx_v_result;
+      goto __pyx_L6_except_return;
+    }
+    __pyx_L3_error:;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "View.MemoryView":494
+ *         try:
+ *             result = struct.unpack(self.view.format, bytesitem)
+ *         except struct.error:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Unable to convert item to object")
+ *         else:
+ */
+    __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 494, __pyx_L5_except_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9);
+    __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0;
+    if (__pyx_t_8) {
+      __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(2, 494, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_1);
+
+      /* "View.MemoryView":495
+ *             result = struct.unpack(self.view.format, bytesitem)
+ *         except struct.error:
+ *             raise ValueError("Unable to convert item to object")             # <<<<<<<<<<<<<<
+ *         else:
+ *             if len(self.view.format) == 1:
+ */
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 495, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(2, 495, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "View.MemoryView":492
+ * 
+ *         bytesitem = itemp[:self.view.itemsize]
+ *         try:             # <<<<<<<<<<<<<<
+ *             result = struct.unpack(self.view.format, bytesitem)
+ *         except struct.error:
+ */
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L1_error;
+    __pyx_L6_except_return:;
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
+    goto __pyx_L0;
+  }
+
+  /* "View.MemoryView":485
+ *         self.assign_item_from_object(itemp, value)
+ * 
+ *     cdef convert_item_to_object(self, char *itemp):             # <<<<<<<<<<<<<<
+ *         """Only used if instantiated manually by the user, or if Cython doesn't
+ *         know how to convert the type"""
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_struct);
+  __Pyx_XDECREF(__pyx_v_bytesitem);
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":501
+ *             return result
+ * 
+ *     cdef assign_item_from_object(self, char *itemp, object value):             # <<<<<<<<<<<<<<
+ *         """Only used if instantiated manually by the user, or if Cython doesn't
+ *         know how to convert the type"""
+ */
+
+static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
+  PyObject *__pyx_v_struct = NULL;
+  char __pyx_v_c;
+  PyObject *__pyx_v_bytesvalue = 0;
+  Py_ssize_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  Py_ssize_t __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  char *__pyx_t_11;
+  char *__pyx_t_12;
+  char *__pyx_t_13;
+  char *__pyx_t_14;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("assign_item_from_object", 0);
+
+  /* "View.MemoryView":504
+ *         """Only used if instantiated manually by the user, or if Cython doesn't
+ *         know how to convert the type"""
+ *         import struct             # <<<<<<<<<<<<<<
+ *         cdef char c
+ *         cdef bytes bytesvalue
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 504, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_struct = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":509
+ *         cdef Py_ssize_t i
+ * 
+ *         if isinstance(value, tuple):             # <<<<<<<<<<<<<<
+ *             bytesvalue = struct.pack(self.view.format, *value)
+ *         else:
+ */
+  __pyx_t_2 = PyTuple_Check(__pyx_v_value); 
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "View.MemoryView":510
+ * 
+ *         if isinstance(value, tuple):
+ *             bytesvalue = struct.pack(self.view.format, *value)             # <<<<<<<<<<<<<<
+ *         else:
+ *             bytesvalue = struct.pack(self.view.format, value)
+ */
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 510, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 510, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 510, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 510, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 510, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 510, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(2, 510, __pyx_L1_error)
+    __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "View.MemoryView":509
+ *         cdef Py_ssize_t i
+ * 
+ *         if isinstance(value, tuple):             # <<<<<<<<<<<<<<
+ *             bytesvalue = struct.pack(self.view.format, *value)
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":512
+ *             bytesvalue = struct.pack(self.view.format, *value)
+ *         else:
+ *             bytesvalue = struct.pack(self.view.format, value)             # <<<<<<<<<<<<<<
+ * 
+ *         for i, c in enumerate(bytesvalue):
+ */
+  /*else*/ {
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 512, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 512, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_5)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_6)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value};
+      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 512, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value};
+      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 512, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 512, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      if (__pyx_t_5) {
+        __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_1);
+      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1);
+      __Pyx_INCREF(__pyx_v_value);
+      __Pyx_GIVEREF(__pyx_v_value);
+      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value);
+      __pyx_t_1 = 0;
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 512, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(2, 512, __pyx_L1_error)
+    __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":514
+ *             bytesvalue = struct.pack(self.view.format, value)
+ * 
+ *         for i, c in enumerate(bytesvalue):             # <<<<<<<<<<<<<<
+ *             itemp[i] = c
+ * 
+ */
+  __pyx_t_9 = 0;
+  if (unlikely(__pyx_v_bytesvalue == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable");
+    __PYX_ERR(2, 514, __pyx_L1_error)
+  }
+  __Pyx_INCREF(__pyx_v_bytesvalue);
+  __pyx_t_10 = __pyx_v_bytesvalue;
+  __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10);
+  __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10));
+  for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) {
+    __pyx_t_11 = __pyx_t_14;
+    __pyx_v_c = (__pyx_t_11[0]);
+
+    /* "View.MemoryView":515
+ * 
+ *         for i, c in enumerate(bytesvalue):
+ *             itemp[i] = c             # <<<<<<<<<<<<<<
+ * 
+ *     @cname('getbuffer')
+ */
+    __pyx_v_i = __pyx_t_9;
+
+    /* "View.MemoryView":514
+ *             bytesvalue = struct.pack(self.view.format, value)
+ * 
+ *         for i, c in enumerate(bytesvalue):             # <<<<<<<<<<<<<<
+ *             itemp[i] = c
+ * 
+ */
+    __pyx_t_9 = (__pyx_t_9 + 1);
+
+    /* "View.MemoryView":515
+ * 
+ *         for i, c in enumerate(bytesvalue):
+ *             itemp[i] = c             # <<<<<<<<<<<<<<
+ * 
+ *     @cname('getbuffer')
+ */
+    (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c;
+  }
+  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+  /* "View.MemoryView":501
+ *             return result
+ * 
+ *     cdef assign_item_from_object(self, char *itemp, object value):             # <<<<<<<<<<<<<<
+ *         """Only used if instantiated manually by the user, or if Cython doesn't
+ *         know how to convert the type"""
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_struct);
+  __Pyx_XDECREF(__pyx_v_bytesvalue);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":518
+ * 
+ *     @cname('getbuffer')
+ *     def __getbuffer__(self, Py_buffer *info, int flags):             # <<<<<<<<<<<<<<
+ *         if flags & PyBUF_WRITABLE and self.view.readonly:
+ *             raise ValueError("Cannot create writable memory view from read-only memoryview")
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t *__pyx_t_4;
+  char *__pyx_t_5;
+  void *__pyx_t_6;
+  int __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  if (__pyx_v_info == NULL) {
+    PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
+    return -1;
+  }
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(__pyx_v_info->obj);
+
+  /* "View.MemoryView":519
+ *     @cname('getbuffer')
+ *     def __getbuffer__(self, Py_buffer *info, int flags):
+ *         if flags & PyBUF_WRITABLE and self.view.readonly:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Cannot create writable memory view from read-only memoryview")
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->view.readonly != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (unlikely(__pyx_t_1)) {
+
+    /* "View.MemoryView":520
+ *     def __getbuffer__(self, Py_buffer *info, int flags):
+ *         if flags & PyBUF_WRITABLE and self.view.readonly:
+ *             raise ValueError("Cannot create writable memory view from read-only memoryview")             # <<<<<<<<<<<<<<
+ * 
+ *         if flags & PyBUF_ND:
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 520, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 520, __pyx_L1_error)
+
+    /* "View.MemoryView":519
+ *     @cname('getbuffer')
+ *     def __getbuffer__(self, Py_buffer *info, int flags):
+ *         if flags & PyBUF_WRITABLE and self.view.readonly:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Cannot create writable memory view from read-only memoryview")
+ * 
+ */
+  }
+
+  /* "View.MemoryView":522
+ *             raise ValueError("Cannot create writable memory view from read-only memoryview")
+ * 
+ *         if flags & PyBUF_ND:             # <<<<<<<<<<<<<<
+ *             info.shape = self.view.shape
+ *         else:
+ */
+  __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":523
+ * 
+ *         if flags & PyBUF_ND:
+ *             info.shape = self.view.shape             # <<<<<<<<<<<<<<
+ *         else:
+ *             info.shape = NULL
+ */
+    __pyx_t_4 = __pyx_v_self->view.shape;
+    __pyx_v_info->shape = __pyx_t_4;
+
+    /* "View.MemoryView":522
+ *             raise ValueError("Cannot create writable memory view from read-only memoryview")
+ * 
+ *         if flags & PyBUF_ND:             # <<<<<<<<<<<<<<
+ *             info.shape = self.view.shape
+ *         else:
+ */
+    goto __pyx_L6;
+  }
+
+  /* "View.MemoryView":525
+ *             info.shape = self.view.shape
+ *         else:
+ *             info.shape = NULL             # <<<<<<<<<<<<<<
+ * 
+ *         if flags & PyBUF_STRIDES:
+ */
+  /*else*/ {
+    __pyx_v_info->shape = NULL;
+  }
+  __pyx_L6:;
+
+  /* "View.MemoryView":527
+ *             info.shape = NULL
+ * 
+ *         if flags & PyBUF_STRIDES:             # <<<<<<<<<<<<<<
+ *             info.strides = self.view.strides
+ *         else:
+ */
+  __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":528
+ * 
+ *         if flags & PyBUF_STRIDES:
+ *             info.strides = self.view.strides             # <<<<<<<<<<<<<<
+ *         else:
+ *             info.strides = NULL
+ */
+    __pyx_t_4 = __pyx_v_self->view.strides;
+    __pyx_v_info->strides = __pyx_t_4;
+
+    /* "View.MemoryView":527
+ *             info.shape = NULL
+ * 
+ *         if flags & PyBUF_STRIDES:             # <<<<<<<<<<<<<<
+ *             info.strides = self.view.strides
+ *         else:
+ */
+    goto __pyx_L7;
+  }
+
+  /* "View.MemoryView":530
+ *             info.strides = self.view.strides
+ *         else:
+ *             info.strides = NULL             # <<<<<<<<<<<<<<
+ * 
+ *         if flags & PyBUF_INDIRECT:
+ */
+  /*else*/ {
+    __pyx_v_info->strides = NULL;
+  }
+  __pyx_L7:;
+
+  /* "View.MemoryView":532
+ *             info.strides = NULL
+ * 
+ *         if flags & PyBUF_INDIRECT:             # <<<<<<<<<<<<<<
+ *             info.suboffsets = self.view.suboffsets
+ *         else:
+ */
+  __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":533
+ * 
+ *         if flags & PyBUF_INDIRECT:
+ *             info.suboffsets = self.view.suboffsets             # <<<<<<<<<<<<<<
+ *         else:
+ *             info.suboffsets = NULL
+ */
+    __pyx_t_4 = __pyx_v_self->view.suboffsets;
+    __pyx_v_info->suboffsets = __pyx_t_4;
+
+    /* "View.MemoryView":532
+ *             info.strides = NULL
+ * 
+ *         if flags & PyBUF_INDIRECT:             # <<<<<<<<<<<<<<
+ *             info.suboffsets = self.view.suboffsets
+ *         else:
+ */
+    goto __pyx_L8;
+  }
+
+  /* "View.MemoryView":535
+ *             info.suboffsets = self.view.suboffsets
+ *         else:
+ *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
+ * 
+ *         if flags & PyBUF_FORMAT:
+ */
+  /*else*/ {
+    __pyx_v_info->suboffsets = NULL;
+  }
+  __pyx_L8:;
+
+  /* "View.MemoryView":537
+ *             info.suboffsets = NULL
+ * 
+ *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
+ *             info.format = self.view.format
+ *         else:
+ */
+  __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":538
+ * 
+ *         if flags & PyBUF_FORMAT:
+ *             info.format = self.view.format             # <<<<<<<<<<<<<<
+ *         else:
+ *             info.format = NULL
+ */
+    __pyx_t_5 = __pyx_v_self->view.format;
+    __pyx_v_info->format = __pyx_t_5;
+
+    /* "View.MemoryView":537
+ *             info.suboffsets = NULL
+ * 
+ *         if flags & PyBUF_FORMAT:             # <<<<<<<<<<<<<<
+ *             info.format = self.view.format
+ *         else:
+ */
+    goto __pyx_L9;
+  }
+
+  /* "View.MemoryView":540
+ *             info.format = self.view.format
+ *         else:
+ *             info.format = NULL             # <<<<<<<<<<<<<<
+ * 
+ *         info.buf = self.view.buf
+ */
+  /*else*/ {
+    __pyx_v_info->format = NULL;
+  }
+  __pyx_L9:;
+
+  /* "View.MemoryView":542
+ *             info.format = NULL
+ * 
+ *         info.buf = self.view.buf             # <<<<<<<<<<<<<<
+ *         info.ndim = self.view.ndim
+ *         info.itemsize = self.view.itemsize
+ */
+  __pyx_t_6 = __pyx_v_self->view.buf;
+  __pyx_v_info->buf = __pyx_t_6;
+
+  /* "View.MemoryView":543
+ * 
+ *         info.buf = self.view.buf
+ *         info.ndim = self.view.ndim             # <<<<<<<<<<<<<<
+ *         info.itemsize = self.view.itemsize
+ *         info.len = self.view.len
+ */
+  __pyx_t_7 = __pyx_v_self->view.ndim;
+  __pyx_v_info->ndim = __pyx_t_7;
+
+  /* "View.MemoryView":544
+ *         info.buf = self.view.buf
+ *         info.ndim = self.view.ndim
+ *         info.itemsize = self.view.itemsize             # <<<<<<<<<<<<<<
+ *         info.len = self.view.len
+ *         info.readonly = self.view.readonly
+ */
+  __pyx_t_8 = __pyx_v_self->view.itemsize;
+  __pyx_v_info->itemsize = __pyx_t_8;
+
+  /* "View.MemoryView":545
+ *         info.ndim = self.view.ndim
+ *         info.itemsize = self.view.itemsize
+ *         info.len = self.view.len             # <<<<<<<<<<<<<<
+ *         info.readonly = self.view.readonly
+ *         info.obj = self
+ */
+  __pyx_t_8 = __pyx_v_self->view.len;
+  __pyx_v_info->len = __pyx_t_8;
+
+  /* "View.MemoryView":546
+ *         info.itemsize = self.view.itemsize
+ *         info.len = self.view.len
+ *         info.readonly = self.view.readonly             # <<<<<<<<<<<<<<
+ *         info.obj = self
+ * 
+ */
+  __pyx_t_1 = __pyx_v_self->view.readonly;
+  __pyx_v_info->readonly = __pyx_t_1;
+
+  /* "View.MemoryView":547
+ *         info.len = self.view.len
+ *         info.readonly = self.view.readonly
+ *         info.obj = self             # <<<<<<<<<<<<<<
+ * 
+ *     __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  __Pyx_GOTREF(__pyx_v_info->obj);
+  __Pyx_DECREF(__pyx_v_info->obj);
+  __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+
+  /* "View.MemoryView":518
+ * 
+ *     @cname('getbuffer')
+ *     def __getbuffer__(self, Py_buffer *info, int flags):             # <<<<<<<<<<<<<<
+ *         if flags & PyBUF_WRITABLE and self.view.readonly:
+ *             raise ValueError("Cannot create writable memory view from read-only memoryview")
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_info->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_info->obj == Py_None) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+  }
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":553
+ * 
+ *     @property
+ *     def T(self):             # <<<<<<<<<<<<<<
+ *         cdef _memoryviewslice result = memoryview_copy(self)
+ *         transpose_memslice(&result.from_slice)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":554
+ *     @property
+ *     def T(self):
+ *         cdef _memoryviewslice result = memoryview_copy(self)             # <<<<<<<<<<<<<<
+ *         transpose_memslice(&result.from_slice)
+ *         return result
+ */
+  __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 554, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(2, 554, __pyx_L1_error)
+  __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":555
+ *     def T(self):
+ *         cdef _memoryviewslice result = memoryview_copy(self)
+ *         transpose_memslice(&result.from_slice)             # <<<<<<<<<<<<<<
+ *         return result
+ * 
+ */
+  __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(2, 555, __pyx_L1_error)
+
+  /* "View.MemoryView":556
+ *         cdef _memoryviewslice result = memoryview_copy(self)
+ *         transpose_memslice(&result.from_slice)
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "View.MemoryView":553
+ * 
+ *     @property
+ *     def T(self):             # <<<<<<<<<<<<<<
+ *         cdef _memoryviewslice result = memoryview_copy(self)
+ *         transpose_memslice(&result.from_slice)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":559
+ * 
+ *     @property
+ *     def base(self):             # <<<<<<<<<<<<<<
+ *         return self.obj
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":560
+ *     @property
+ *     def base(self):
+ *         return self.obj             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->obj);
+  __pyx_r = __pyx_v_self->obj;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":559
+ * 
+ *     @property
+ *     def base(self):             # <<<<<<<<<<<<<<
+ *         return self.obj
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":563
+ * 
+ *     @property
+ *     def shape(self):             # <<<<<<<<<<<<<<
+ *         return tuple([length for length in self.view.shape[:self.view.ndim]])
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  Py_ssize_t __pyx_v_length;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t *__pyx_t_2;
+  Py_ssize_t *__pyx_t_3;
+  Py_ssize_t *__pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":564
+ *     @property
+ *     def shape(self):
+ *         return tuple([length for length in self.view.shape[:self.view.ndim]])             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 564, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
+  for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
+    __pyx_t_2 = __pyx_t_4;
+    __pyx_v_length = (__pyx_t_2[0]);
+    __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 564, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 564, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+  __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 564, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":563
+ * 
+ *     @property
+ *     def shape(self):             # <<<<<<<<<<<<<<
+ *         return tuple([length for length in self.view.shape[:self.view.ndim]])
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":567
+ * 
+ *     @property
+ *     def strides(self):             # <<<<<<<<<<<<<<
+ *         if self.view.strides == NULL:
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  Py_ssize_t __pyx_v_stride;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t *__pyx_t_3;
+  Py_ssize_t *__pyx_t_4;
+  Py_ssize_t *__pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":568
+ *     @property
+ *     def strides(self):
+ *         if self.view.strides == NULL:             # <<<<<<<<<<<<<<
+ * 
+ *             raise ValueError("Buffer view does not expose strides")
+ */
+  __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "View.MemoryView":570
+ *         if self.view.strides == NULL:
+ * 
+ *             raise ValueError("Buffer view does not expose strides")             # <<<<<<<<<<<<<<
+ * 
+ *         return tuple([stride for stride in self.view.strides[:self.view.ndim]])
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 570, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(2, 570, __pyx_L1_error)
+
+    /* "View.MemoryView":568
+ *     @property
+ *     def strides(self):
+ *         if self.view.strides == NULL:             # <<<<<<<<<<<<<<
+ * 
+ *             raise ValueError("Buffer view does not expose strides")
+ */
+  }
+
+  /* "View.MemoryView":572
+ *             raise ValueError("Buffer view does not expose strides")
+ * 
+ *         return tuple([stride for stride in self.view.strides[:self.view.ndim]])             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 572, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim);
+  for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
+    __pyx_t_3 = __pyx_t_5;
+    __pyx_v_stride = (__pyx_t_3[0]);
+    __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 572, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(2, 572, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  }
+  __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 572, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_6;
+  __pyx_t_6 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":567
+ * 
+ *     @property
+ *     def strides(self):             # <<<<<<<<<<<<<<
+ *         if self.view.strides == NULL:
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":575
+ * 
+ *     @property
+ *     def suboffsets(self):             # <<<<<<<<<<<<<<
+ *         if self.view.suboffsets == NULL:
+ *             return (-1,) * self.view.ndim
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  Py_ssize_t __pyx_v_suboffset;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t *__pyx_t_4;
+  Py_ssize_t *__pyx_t_5;
+  Py_ssize_t *__pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":576
+ *     @property
+ *     def suboffsets(self):
+ *         if self.view.suboffsets == NULL:             # <<<<<<<<<<<<<<
+ *             return (-1,) * self.view.ndim
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":577
+ *     def suboffsets(self):
+ *         if self.view.suboffsets == NULL:
+ *             return (-1,) * self.view.ndim             # <<<<<<<<<<<<<<
+ * 
+ *         return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 577, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__30, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 577, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_r = __pyx_t_3;
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "View.MemoryView":576
+ *     @property
+ *     def suboffsets(self):
+ *         if self.view.suboffsets == NULL:             # <<<<<<<<<<<<<<
+ *             return (-1,) * self.view.ndim
+ * 
+ */
+  }
+
+  /* "View.MemoryView":579
+ *             return (-1,) * self.view.ndim
+ * 
+ *         return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 579, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim);
+  for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) {
+    __pyx_t_4 = __pyx_t_6;
+    __pyx_v_suboffset = (__pyx_t_4[0]);
+    __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 579, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(2, 579, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 579, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":575
+ * 
+ *     @property
+ *     def suboffsets(self):             # <<<<<<<<<<<<<<
+ *         if self.view.suboffsets == NULL:
+ *             return (-1,) * self.view.ndim
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":582
+ * 
+ *     @property
+ *     def ndim(self):             # <<<<<<<<<<<<<<
+ *         return self.view.ndim
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":583
+ *     @property
+ *     def ndim(self):
+ *         return self.view.ndim             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 583, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":582
+ * 
+ *     @property
+ *     def ndim(self):             # <<<<<<<<<<<<<<
+ *         return self.view.ndim
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":586
+ * 
+ *     @property
+ *     def itemsize(self):             # <<<<<<<<<<<<<<
+ *         return self.view.itemsize
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":587
+ *     @property
+ *     def itemsize(self):
+ *         return self.view.itemsize             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 587, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":586
+ * 
+ *     @property
+ *     def itemsize(self):             # <<<<<<<<<<<<<<
+ *         return self.view.itemsize
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":590
+ * 
+ *     @property
+ *     def nbytes(self):             # <<<<<<<<<<<<<<
+ *         return self.size * self.view.itemsize
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":591
+ *     @property
+ *     def nbytes(self):
+ *         return self.size * self.view.itemsize             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 591, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 591, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 591, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":590
+ * 
+ *     @property
+ *     def nbytes(self):             # <<<<<<<<<<<<<<
+ *         return self.size * self.view.itemsize
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":594
+ * 
+ *     @property
+ *     def size(self):             # <<<<<<<<<<<<<<
+ *         if self._size is None:
+ *             result = 1
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  PyObject *__pyx_v_result = NULL;
+  PyObject *__pyx_v_length = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  Py_ssize_t *__pyx_t_3;
+  Py_ssize_t *__pyx_t_4;
+  Py_ssize_t *__pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":595
+ *     @property
+ *     def size(self):
+ *         if self._size is None:             # <<<<<<<<<<<<<<
+ *             result = 1
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_self->_size == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":596
+ *     def size(self):
+ *         if self._size is None:
+ *             result = 1             # <<<<<<<<<<<<<<
+ * 
+ *             for length in self.view.shape[:self.view.ndim]:
+ */
+    __Pyx_INCREF(__pyx_int_1);
+    __pyx_v_result = __pyx_int_1;
+
+    /* "View.MemoryView":598
+ *             result = 1
+ * 
+ *             for length in self.view.shape[:self.view.ndim]:             # <<<<<<<<<<<<<<
+ *                 result *= length
+ * 
+ */
+    __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim);
+    for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) {
+      __pyx_t_3 = __pyx_t_5;
+      __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 598, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6);
+      __pyx_t_6 = 0;
+
+      /* "View.MemoryView":599
+ * 
+ *             for length in self.view.shape[:self.view.ndim]:
+ *                 result *= length             # <<<<<<<<<<<<<<
+ * 
+ *             self._size = result
+ */
+      __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 599, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6);
+      __pyx_t_6 = 0;
+    }
+
+    /* "View.MemoryView":601
+ *                 result *= length
+ * 
+ *             self._size = result             # <<<<<<<<<<<<<<
+ * 
+ *         return self._size
+ */
+    __Pyx_INCREF(__pyx_v_result);
+    __Pyx_GIVEREF(__pyx_v_result);
+    __Pyx_GOTREF(__pyx_v_self->_size);
+    __Pyx_DECREF(__pyx_v_self->_size);
+    __pyx_v_self->_size = __pyx_v_result;
+
+    /* "View.MemoryView":595
+ *     @property
+ *     def size(self):
+ *         if self._size is None:             # <<<<<<<<<<<<<<
+ *             result = 1
+ * 
+ */
+  }
+
+  /* "View.MemoryView":603
+ *             self._size = result
+ * 
+ *         return self._size             # <<<<<<<<<<<<<<
+ * 
+ *     def __len__(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->_size);
+  __pyx_r = __pyx_v_self->_size;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":594
+ * 
+ *     @property
+ *     def size(self):             # <<<<<<<<<<<<<<
+ *         if self._size is None:
+ *             result = 1
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XDECREF(__pyx_v_length);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":605
+ *         return self._size
+ * 
+ *     def __len__(self):             # <<<<<<<<<<<<<<
+ *         if self.view.ndim >= 1:
+ *             return self.view.shape[0]
+ */
+
+/* Python wrapper */
+static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/
+static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) {
+  Py_ssize_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__len__ (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  Py_ssize_t __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__len__", 0);
+
+  /* "View.MemoryView":606
+ * 
+ *     def __len__(self):
+ *         if self.view.ndim >= 1:             # <<<<<<<<<<<<<<
+ *             return self.view.shape[0]
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":607
+ *     def __len__(self):
+ *         if self.view.ndim >= 1:
+ *             return self.view.shape[0]             # <<<<<<<<<<<<<<
+ * 
+ *         return 0
+ */
+    __pyx_r = (__pyx_v_self->view.shape[0]);
+    goto __pyx_L0;
+
+    /* "View.MemoryView":606
+ * 
+ *     def __len__(self):
+ *         if self.view.ndim >= 1:             # <<<<<<<<<<<<<<
+ *             return self.view.shape[0]
+ * 
+ */
+  }
+
+  /* "View.MemoryView":609
+ *             return self.view.shape[0]
+ * 
+ *         return 0             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+  __pyx_r = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":605
+ *         return self._size
+ * 
+ *     def __len__(self):             # <<<<<<<<<<<<<<
+ *         if self.view.ndim >= 1:
+ *             return self.view.shape[0]
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":611
+ *         return 0
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "" % (self.base.__class__.__name__,
+ *                                                id(self))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "View.MemoryView":612
+ * 
+ *     def __repr__(self):
+ *         return "" % (self.base.__class__.__name__,             # <<<<<<<<<<<<<<
+ *                                                id(self))
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 612, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 612, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 612, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "View.MemoryView":613
+ *     def __repr__(self):
+ *         return "" % (self.base.__class__.__name__,
+ *                                                id(self))             # <<<<<<<<<<<<<<
+ * 
+ *     def __str__(self):
+ */
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 613, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "View.MemoryView":612
+ * 
+ *     def __repr__(self):
+ *         return "" % (self.base.__class__.__name__,             # <<<<<<<<<<<<<<
+ *                                                id(self))
+ * 
+ */
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 612, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 612, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":611
+ *         return 0
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "" % (self.base.__class__.__name__,
+ *                                                id(self))
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":615
+ *                                                id(self))
+ * 
+ *     def __str__(self):             # <<<<<<<<<<<<<<
+ *         return "" % (self.base.__class__.__name__,)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__str__", 0);
+
+  /* "View.MemoryView":616
+ * 
+ *     def __str__(self):
+ *         return "" % (self.base.__class__.__name__,)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 616, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 616, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 616, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 616, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 616, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":615
+ *                                                id(self))
+ * 
+ *     def __str__(self):             # <<<<<<<<<<<<<<
+ *         return "" % (self.base.__class__.__name__,)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":619
+ * 
+ * 
+ *     def is_c_contig(self):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice *mslice
+ *         cdef __Pyx_memviewslice tmp
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) {
+  __Pyx_memviewslice *__pyx_v_mslice;
+  __Pyx_memviewslice __pyx_v_tmp;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_memviewslice *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("is_c_contig", 0);
+
+  /* "View.MemoryView":622
+ *         cdef __Pyx_memviewslice *mslice
+ *         cdef __Pyx_memviewslice tmp
+ *         mslice = get_slice_from_memview(self, &tmp)             # <<<<<<<<<<<<<<
+ *         return slice_is_contig(mslice[0], 'C', self.view.ndim)
+ * 
+ */
+  __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 622, __pyx_L1_error)
+  __pyx_v_mslice = __pyx_t_1;
+
+  /* "View.MemoryView":623
+ *         cdef __Pyx_memviewslice tmp
+ *         mslice = get_slice_from_memview(self, &tmp)
+ *         return slice_is_contig(mslice[0], 'C', self.view.ndim)             # <<<<<<<<<<<<<<
+ * 
+ *     def is_f_contig(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 623, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":619
+ * 
+ * 
+ *     def is_c_contig(self):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice *mslice
+ *         cdef __Pyx_memviewslice tmp
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":625
+ *         return slice_is_contig(mslice[0], 'C', self.view.ndim)
+ * 
+ *     def is_f_contig(self):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice *mslice
+ *         cdef __Pyx_memviewslice tmp
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) {
+  __Pyx_memviewslice *__pyx_v_mslice;
+  __Pyx_memviewslice __pyx_v_tmp;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_memviewslice *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("is_f_contig", 0);
+
+  /* "View.MemoryView":628
+ *         cdef __Pyx_memviewslice *mslice
+ *         cdef __Pyx_memviewslice tmp
+ *         mslice = get_slice_from_memview(self, &tmp)             # <<<<<<<<<<<<<<
+ *         return slice_is_contig(mslice[0], 'F', self.view.ndim)
+ * 
+ */
+  __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 628, __pyx_L1_error)
+  __pyx_v_mslice = __pyx_t_1;
+
+  /* "View.MemoryView":629
+ *         cdef __Pyx_memviewslice tmp
+ *         mslice = get_slice_from_memview(self, &tmp)
+ *         return slice_is_contig(mslice[0], 'F', self.view.ndim)             # <<<<<<<<<<<<<<
+ * 
+ *     def copy(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 629, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":625
+ *         return slice_is_contig(mslice[0], 'C', self.view.ndim)
+ * 
+ *     def is_f_contig(self):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice *mslice
+ *         cdef __Pyx_memviewslice tmp
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":631
+ *         return slice_is_contig(mslice[0], 'F', self.view.ndim)
+ * 
+ *     def copy(self):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice mslice
+ *         cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) {
+  __Pyx_memviewslice __pyx_v_mslice;
+  int __pyx_v_flags;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_memviewslice __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("copy", 0);
+
+  /* "View.MemoryView":633
+ *     def copy(self):
+ *         cdef __Pyx_memviewslice mslice
+ *         cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS             # <<<<<<<<<<<<<<
+ * 
+ *         slice_copy(self, &mslice)
+ */
+  __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS));
+
+  /* "View.MemoryView":635
+ *         cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
+ * 
+ *         slice_copy(self, &mslice)             # <<<<<<<<<<<<<<
+ *         mslice = slice_copy_contig(&mslice, "c", self.view.ndim,
+ *                                    self.view.itemsize,
+ */
+  __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice));
+
+  /* "View.MemoryView":636
+ * 
+ *         slice_copy(self, &mslice)
+ *         mslice = slice_copy_contig(&mslice, "c", self.view.ndim,             # <<<<<<<<<<<<<<
+ *                                    self.view.itemsize,
+ *                                    flags|PyBUF_C_CONTIGUOUS,
+ */
+  __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 636, __pyx_L1_error)
+  __pyx_v_mslice = __pyx_t_1;
+
+  /* "View.MemoryView":641
+ *                                    self.dtype_is_object)
+ * 
+ *         return memoryview_copy_from_slice(self, &mslice)             # <<<<<<<<<<<<<<
+ * 
+ *     def copy_fortran(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 641, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":631
+ *         return slice_is_contig(mslice[0], 'F', self.view.ndim)
+ * 
+ *     def copy(self):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice mslice
+ *         cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":643
+ *         return memoryview_copy_from_slice(self, &mslice)
+ * 
+ *     def copy_fortran(self):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice src, dst
+ *         cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0);
+  __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) {
+  __Pyx_memviewslice __pyx_v_src;
+  __Pyx_memviewslice __pyx_v_dst;
+  int __pyx_v_flags;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_memviewslice __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("copy_fortran", 0);
+
+  /* "View.MemoryView":645
+ *     def copy_fortran(self):
+ *         cdef __Pyx_memviewslice src, dst
+ *         cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS             # <<<<<<<<<<<<<<
+ * 
+ *         slice_copy(self, &src)
+ */
+  __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS));
+
+  /* "View.MemoryView":647
+ *         cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
+ * 
+ *         slice_copy(self, &src)             # <<<<<<<<<<<<<<
+ *         dst = slice_copy_contig(&src, "fortran", self.view.ndim,
+ *                                 self.view.itemsize,
+ */
+  __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src));
+
+  /* "View.MemoryView":648
+ * 
+ *         slice_copy(self, &src)
+ *         dst = slice_copy_contig(&src, "fortran", self.view.ndim,             # <<<<<<<<<<<<<<
+ *                                 self.view.itemsize,
+ *                                 flags|PyBUF_F_CONTIGUOUS,
+ */
+  __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 648, __pyx_L1_error)
+  __pyx_v_dst = __pyx_t_1;
+
+  /* "View.MemoryView":653
+ *                                 self.dtype_is_object)
+ * 
+ *         return memoryview_copy_from_slice(self, &dst)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 653, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":643
+ *         return memoryview_copy_from_slice(self, &mslice)
+ * 
+ *     def copy_fortran(self):             # <<<<<<<<<<<<<<
+ *         cdef __Pyx_memviewslice src, dst
+ *         cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __PYX_ERR(2, 2, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+  __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __PYX_ERR(2, 4, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":657
+ * 
+ * @cname('__pyx_memoryview_new')
+ * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):             # <<<<<<<<<<<<<<
+ *     cdef memoryview result = memoryview(o, flags, dtype_is_object)
+ *     result.typeinfo = typeinfo
+ */
+
+static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) {
+  struct __pyx_memoryview_obj *__pyx_v_result = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("memoryview_cwrapper", 0);
+
+  /* "View.MemoryView":658
+ * @cname('__pyx_memoryview_new')
+ * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
+ *     cdef memoryview result = memoryview(o, flags, dtype_is_object)             # <<<<<<<<<<<<<<
+ *     result.typeinfo = typeinfo
+ *     return result
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_v_o);
+  __Pyx_GIVEREF(__pyx_v_o);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "View.MemoryView":659
+ * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
+ *     cdef memoryview result = memoryview(o, flags, dtype_is_object)
+ *     result.typeinfo = typeinfo             # <<<<<<<<<<<<<<
+ *     return result
+ * 
+ */
+  __pyx_v_result->typeinfo = __pyx_v_typeinfo;
+
+  /* "View.MemoryView":660
+ *     cdef memoryview result = memoryview(o, flags, dtype_is_object)
+ *     result.typeinfo = typeinfo
+ *     return result             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_check')
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "View.MemoryView":657
+ * 
+ * @cname('__pyx_memoryview_new')
+ * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):             # <<<<<<<<<<<<<<
+ *     cdef memoryview result = memoryview(o, flags, dtype_is_object)
+ *     result.typeinfo = typeinfo
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":663
+ * 
+ * @cname('__pyx_memoryview_check')
+ * cdef inline bint memoryview_check(object o):             # <<<<<<<<<<<<<<
+ *     return isinstance(o, memoryview)
+ * 
+ */
+
+static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("memoryview_check", 0);
+
+  /* "View.MemoryView":664
+ * @cname('__pyx_memoryview_check')
+ * cdef inline bint memoryview_check(object o):
+ *     return isinstance(o, memoryview)             # <<<<<<<<<<<<<<
+ * 
+ * cdef tuple _unellipsify(object index, int ndim):
+ */
+  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); 
+  __pyx_r = __pyx_t_1;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":663
+ * 
+ * @cname('__pyx_memoryview_check')
+ * cdef inline bint memoryview_check(object o):             # <<<<<<<<<<<<<<
+ *     return isinstance(o, memoryview)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":666
+ *     return isinstance(o, memoryview)
+ * 
+ * cdef tuple _unellipsify(object index, int ndim):             # <<<<<<<<<<<<<<
+ *     """
+ *     Replace all ellipses with full slices and fill incomplete indices with
+ */
+
+static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) {
+  PyObject *__pyx_v_tup = NULL;
+  PyObject *__pyx_v_result = NULL;
+  int __pyx_v_have_slices;
+  int __pyx_v_seen_ellipsis;
+  CYTHON_UNUSED PyObject *__pyx_v_idx = NULL;
+  PyObject *__pyx_v_item = NULL;
+  Py_ssize_t __pyx_v_nslices;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  Py_ssize_t __pyx_t_5;
+  PyObject *(*__pyx_t_6)(PyObject *);
+  PyObject *__pyx_t_7 = NULL;
+  Py_ssize_t __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_unellipsify", 0);
+
+  /* "View.MemoryView":671
+ *     full slices.
+ *     """
+ *     if not isinstance(index, tuple):             # <<<<<<<<<<<<<<
+ *         tup = (index,)
+ *     else:
+ */
+  __pyx_t_1 = PyTuple_Check(__pyx_v_index); 
+  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":672
+ *     """
+ *     if not isinstance(index, tuple):
+ *         tup = (index,)             # <<<<<<<<<<<<<<
+ *     else:
+ *         tup = index
+ */
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 672, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_v_index);
+    __Pyx_GIVEREF(__pyx_v_index);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index);
+    __pyx_v_tup = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "View.MemoryView":671
+ *     full slices.
+ *     """
+ *     if not isinstance(index, tuple):             # <<<<<<<<<<<<<<
+ *         tup = (index,)
+ *     else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":674
+ *         tup = (index,)
+ *     else:
+ *         tup = index             # <<<<<<<<<<<<<<
+ * 
+ *     result = []
+ */
+  /*else*/ {
+    __Pyx_INCREF(__pyx_v_index);
+    __pyx_v_tup = __pyx_v_index;
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":676
+ *         tup = index
+ * 
+ *     result = []             # <<<<<<<<<<<<<<
+ *     have_slices = False
+ *     seen_ellipsis = False
+ */
+  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 676, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_v_result = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "View.MemoryView":677
+ * 
+ *     result = []
+ *     have_slices = False             # <<<<<<<<<<<<<<
+ *     seen_ellipsis = False
+ *     for idx, item in enumerate(tup):
+ */
+  __pyx_v_have_slices = 0;
+
+  /* "View.MemoryView":678
+ *     result = []
+ *     have_slices = False
+ *     seen_ellipsis = False             # <<<<<<<<<<<<<<
+ *     for idx, item in enumerate(tup):
+ *         if item is Ellipsis:
+ */
+  __pyx_v_seen_ellipsis = 0;
+
+  /* "View.MemoryView":679
+ *     have_slices = False
+ *     seen_ellipsis = False
+ *     for idx, item in enumerate(tup):             # <<<<<<<<<<<<<<
+ *         if item is Ellipsis:
+ *             if not seen_ellipsis:
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_3 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) {
+    __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+  } else {
+    __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 679, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 679, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_6)) {
+      if (likely(PyList_CheckExact(__pyx_t_4))) {
+        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(2, 679, __pyx_L1_error)
+        #else
+        __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 679, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        #endif
+      } else {
+        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(2, 679, __pyx_L1_error)
+        #else
+        __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 679, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        #endif
+      }
+    } else {
+      __pyx_t_7 = __pyx_t_6(__pyx_t_4);
+      if (unlikely(!__pyx_t_7)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(2, 679, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_7);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7);
+    __pyx_t_7 = 0;
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3);
+    __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 679, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_3);
+    __pyx_t_3 = __pyx_t_7;
+    __pyx_t_7 = 0;
+
+    /* "View.MemoryView":680
+ *     seen_ellipsis = False
+ *     for idx, item in enumerate(tup):
+ *         if item is Ellipsis:             # <<<<<<<<<<<<<<
+ *             if not seen_ellipsis:
+ *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
+ */
+    __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "View.MemoryView":681
+ *     for idx, item in enumerate(tup):
+ *         if item is Ellipsis:
+ *             if not seen_ellipsis:             # <<<<<<<<<<<<<<
+ *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
+ *                 seen_ellipsis = True
+ */
+      __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0);
+      if (__pyx_t_1) {
+
+        /* "View.MemoryView":682
+ *         if item is Ellipsis:
+ *             if not seen_ellipsis:
+ *                 result.extend([slice(None)] * (ndim - len(tup) + 1))             # <<<<<<<<<<<<<<
+ *                 seen_ellipsis = True
+ *             else:
+ */
+        __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(2, 682, __pyx_L1_error)
+        __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 682, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        { Py_ssize_t __pyx_temp;
+          for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) {
+            __Pyx_INCREF(__pyx_slice_);
+            __Pyx_GIVEREF(__pyx_slice_);
+            PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice_);
+          }
+        }
+        __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 682, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+        /* "View.MemoryView":683
+ *             if not seen_ellipsis:
+ *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
+ *                 seen_ellipsis = True             # <<<<<<<<<<<<<<
+ *             else:
+ *                 result.append(slice(None))
+ */
+        __pyx_v_seen_ellipsis = 1;
+
+        /* "View.MemoryView":681
+ *     for idx, item in enumerate(tup):
+ *         if item is Ellipsis:
+ *             if not seen_ellipsis:             # <<<<<<<<<<<<<<
+ *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
+ *                 seen_ellipsis = True
+ */
+        goto __pyx_L7;
+      }
+
+      /* "View.MemoryView":685
+ *                 seen_ellipsis = True
+ *             else:
+ *                 result.append(slice(None))             # <<<<<<<<<<<<<<
+ *             have_slices = True
+ *         else:
+ */
+      /*else*/ {
+        __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice_); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 685, __pyx_L1_error)
+      }
+      __pyx_L7:;
+
+      /* "View.MemoryView":686
+ *             else:
+ *                 result.append(slice(None))
+ *             have_slices = True             # <<<<<<<<<<<<<<
+ *         else:
+ *             if not isinstance(item, slice) and not PyIndex_Check(item):
+ */
+      __pyx_v_have_slices = 1;
+
+      /* "View.MemoryView":680
+ *     seen_ellipsis = False
+ *     for idx, item in enumerate(tup):
+ *         if item is Ellipsis:             # <<<<<<<<<<<<<<
+ *             if not seen_ellipsis:
+ *                 result.extend([slice(None)] * (ndim - len(tup) + 1))
+ */
+      goto __pyx_L6;
+    }
+
+    /* "View.MemoryView":688
+ *             have_slices = True
+ *         else:
+ *             if not isinstance(item, slice) and not PyIndex_Check(item):             # <<<<<<<<<<<<<<
+ *                 raise TypeError("Cannot index with type '%s'" % type(item))
+ * 
+ */
+    /*else*/ {
+      __pyx_t_2 = PySlice_Check(__pyx_v_item); 
+      __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0);
+      if (__pyx_t_10) {
+      } else {
+        __pyx_t_1 = __pyx_t_10;
+        goto __pyx_L9_bool_binop_done;
+      }
+      __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0);
+      __pyx_t_1 = __pyx_t_10;
+      __pyx_L9_bool_binop_done:;
+      if (unlikely(__pyx_t_1)) {
+
+        /* "View.MemoryView":689
+ *         else:
+ *             if not isinstance(item, slice) and not PyIndex_Check(item):
+ *                 raise TypeError("Cannot index with type '%s'" % type(item))             # <<<<<<<<<<<<<<
+ * 
+ *             have_slices = have_slices or isinstance(item, slice)
+ */
+        __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 689, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 689, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_Raise(__pyx_t_11, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __PYX_ERR(2, 689, __pyx_L1_error)
+
+        /* "View.MemoryView":688
+ *             have_slices = True
+ *         else:
+ *             if not isinstance(item, slice) and not PyIndex_Check(item):             # <<<<<<<<<<<<<<
+ *                 raise TypeError("Cannot index with type '%s'" % type(item))
+ * 
+ */
+      }
+
+      /* "View.MemoryView":691
+ *                 raise TypeError("Cannot index with type '%s'" % type(item))
+ * 
+ *             have_slices = have_slices or isinstance(item, slice)             # <<<<<<<<<<<<<<
+ *             result.append(item)
+ * 
+ */
+      __pyx_t_10 = (__pyx_v_have_slices != 0);
+      if (!__pyx_t_10) {
+      } else {
+        __pyx_t_1 = __pyx_t_10;
+        goto __pyx_L11_bool_binop_done;
+      }
+      __pyx_t_10 = PySlice_Check(__pyx_v_item); 
+      __pyx_t_2 = (__pyx_t_10 != 0);
+      __pyx_t_1 = __pyx_t_2;
+      __pyx_L11_bool_binop_done:;
+      __pyx_v_have_slices = __pyx_t_1;
+
+      /* "View.MemoryView":692
+ * 
+ *             have_slices = have_slices or isinstance(item, slice)
+ *             result.append(item)             # <<<<<<<<<<<<<<
+ * 
+ *     nslices = ndim - len(result)
+ */
+      __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 692, __pyx_L1_error)
+    }
+    __pyx_L6:;
+
+    /* "View.MemoryView":679
+ *     have_slices = False
+ *     seen_ellipsis = False
+ *     for idx, item in enumerate(tup):             # <<<<<<<<<<<<<<
+ *         if item is Ellipsis:
+ *             if not seen_ellipsis:
+ */
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "View.MemoryView":694
+ *             result.append(item)
+ * 
+ *     nslices = ndim - len(result)             # <<<<<<<<<<<<<<
+ *     if nslices:
+ *         result.extend([slice(None)] * nslices)
+ */
+  __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 694, __pyx_L1_error)
+  __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5);
+
+  /* "View.MemoryView":695
+ * 
+ *     nslices = ndim - len(result)
+ *     if nslices:             # <<<<<<<<<<<<<<
+ *         result.extend([slice(None)] * nslices)
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_nslices != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":696
+ *     nslices = ndim - len(result)
+ *     if nslices:
+ *         result.extend([slice(None)] * nslices)             # <<<<<<<<<<<<<<
+ * 
+ *     return have_slices or nslices, tuple(result)
+ */
+    __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 696, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    { Py_ssize_t __pyx_temp;
+      for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) {
+        __Pyx_INCREF(__pyx_slice_);
+        __Pyx_GIVEREF(__pyx_slice_);
+        PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice_);
+      }
+    }
+    __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 696, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "View.MemoryView":695
+ * 
+ *     nslices = ndim - len(result)
+ *     if nslices:             # <<<<<<<<<<<<<<
+ *         result.extend([slice(None)] * nslices)
+ * 
+ */
+  }
+
+  /* "View.MemoryView":698
+ *         result.extend([slice(None)] * nslices)
+ * 
+ *     return have_slices or nslices, tuple(result)             # <<<<<<<<<<<<<<
+ * 
+ * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  if (!__pyx_v_have_slices) {
+  } else {
+    __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 698, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L14_bool_binop_done;
+  }
+  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 698, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __pyx_t_4;
+  __pyx_t_4 = 0;
+  __pyx_L14_bool_binop_done:;
+  __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 698, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 698, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_11);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4);
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = ((PyObject*)__pyx_t_11);
+  __pyx_t_11 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":666
+ *     return isinstance(o, memoryview)
+ * 
+ * cdef tuple _unellipsify(object index, int ndim):             # <<<<<<<<<<<<<<
+ *     """
+ *     Replace all ellipses with full slices and fill incomplete indices with
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_tup);
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XDECREF(__pyx_v_idx);
+  __Pyx_XDECREF(__pyx_v_item);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":700
+ *     return have_slices or nslices, tuple(result)
+ * 
+ * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):             # <<<<<<<<<<<<<<
+ *     for suboffset in suboffsets[:ndim]:
+ *         if suboffset >= 0:
+ */
+
+static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) {
+  Py_ssize_t __pyx_v_suboffset;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t *__pyx_t_1;
+  Py_ssize_t *__pyx_t_2;
+  Py_ssize_t *__pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("assert_direct_dimensions", 0);
+
+  /* "View.MemoryView":701
+ * 
+ * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
+ *     for suboffset in suboffsets[:ndim]:             # <<<<<<<<<<<<<<
+ *         if suboffset >= 0:
+ *             raise ValueError("Indirect dimensions not supported")
+ */
+  __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim);
+  for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) {
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_v_suboffset = (__pyx_t_1[0]);
+
+    /* "View.MemoryView":702
+ * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
+ *     for suboffset in suboffsets[:ndim]:
+ *         if suboffset >= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Indirect dimensions not supported")
+ * 
+ */
+    __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0);
+    if (unlikely(__pyx_t_4)) {
+
+      /* "View.MemoryView":703
+ *     for suboffset in suboffsets[:ndim]:
+ *         if suboffset >= 0:
+ *             raise ValueError("Indirect dimensions not supported")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 703, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __PYX_ERR(2, 703, __pyx_L1_error)
+
+      /* "View.MemoryView":702
+ * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
+ *     for suboffset in suboffsets[:ndim]:
+ *         if suboffset >= 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Indirect dimensions not supported")
+ * 
+ */
+    }
+  }
+
+  /* "View.MemoryView":700
+ *     return have_slices or nslices, tuple(result)
+ * 
+ * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):             # <<<<<<<<<<<<<<
+ *     for suboffset in suboffsets[:ndim]:
+ *         if suboffset >= 0:
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":710
+ * 
+ * @cname('__pyx_memview_slice')
+ * cdef memoryview memview_slice(memoryview memview, object indices):             # <<<<<<<<<<<<<<
+ *     cdef int new_ndim = 0, suboffset_dim = -1, dim
+ *     cdef bint negative_step
+ */
+
+static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) {
+  int __pyx_v_new_ndim;
+  int __pyx_v_suboffset_dim;
+  int __pyx_v_dim;
+  __Pyx_memviewslice __pyx_v_src;
+  __Pyx_memviewslice __pyx_v_dst;
+  __Pyx_memviewslice *__pyx_v_p_src;
+  struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0;
+  __Pyx_memviewslice *__pyx_v_p_dst;
+  int *__pyx_v_p_suboffset_dim;
+  Py_ssize_t __pyx_v_start;
+  Py_ssize_t __pyx_v_stop;
+  Py_ssize_t __pyx_v_step;
+  int __pyx_v_have_start;
+  int __pyx_v_have_stop;
+  int __pyx_v_have_step;
+  PyObject *__pyx_v_index = NULL;
+  struct __pyx_memoryview_obj *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  struct __pyx_memoryview_obj *__pyx_t_4;
+  char *__pyx_t_5;
+  int __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  PyObject *(*__pyx_t_8)(PyObject *);
+  PyObject *__pyx_t_9 = NULL;
+  Py_ssize_t __pyx_t_10;
+  int __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("memview_slice", 0);
+
+  /* "View.MemoryView":711
+ * @cname('__pyx_memview_slice')
+ * cdef memoryview memview_slice(memoryview memview, object indices):
+ *     cdef int new_ndim = 0, suboffset_dim = -1, dim             # <<<<<<<<<<<<<<
+ *     cdef bint negative_step
+ *     cdef __Pyx_memviewslice src, dst
+ */
+  __pyx_v_new_ndim = 0;
+  __pyx_v_suboffset_dim = -1;
+
+  /* "View.MemoryView":718
+ * 
+ * 
+ *     memset(&dst, 0, sizeof(dst))             # <<<<<<<<<<<<<<
+ * 
+ *     cdef _memoryviewslice memviewsliceobj
+ */
+  (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst))));
+
+  /* "View.MemoryView":722
+ *     cdef _memoryviewslice memviewsliceobj
+ * 
+ *     assert memview.view.ndim > 0             # <<<<<<<<<<<<<<
+ * 
+ *     if isinstance(memview, _memoryviewslice):
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(2, 722, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "View.MemoryView":724
+ *     assert memview.view.ndim > 0
+ * 
+ *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
+ *         memviewsliceobj = memview
+ *         p_src = &memviewsliceobj.from_slice
+ */
+  __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":725
+ * 
+ *     if isinstance(memview, _memoryviewslice):
+ *         memviewsliceobj = memview             # <<<<<<<<<<<<<<
+ *         p_src = &memviewsliceobj.from_slice
+ *     else:
+ */
+    if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(2, 725, __pyx_L1_error)
+    __pyx_t_3 = ((PyObject *)__pyx_v_memview);
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "View.MemoryView":726
+ *     if isinstance(memview, _memoryviewslice):
+ *         memviewsliceobj = memview
+ *         p_src = &memviewsliceobj.from_slice             # <<<<<<<<<<<<<<
+ *     else:
+ *         slice_copy(memview, &src)
+ */
+    __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice);
+
+    /* "View.MemoryView":724
+ *     assert memview.view.ndim > 0
+ * 
+ *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
+ *         memviewsliceobj = memview
+ *         p_src = &memviewsliceobj.from_slice
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":728
+ *         p_src = &memviewsliceobj.from_slice
+ *     else:
+ *         slice_copy(memview, &src)             # <<<<<<<<<<<<<<
+ *         p_src = &src
+ * 
+ */
+  /*else*/ {
+    __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src));
+
+    /* "View.MemoryView":729
+ *     else:
+ *         slice_copy(memview, &src)
+ *         p_src = &src             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_v_p_src = (&__pyx_v_src);
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":735
+ * 
+ * 
+ *     dst.memview = p_src.memview             # <<<<<<<<<<<<<<
+ *     dst.data = p_src.data
+ * 
+ */
+  __pyx_t_4 = __pyx_v_p_src->memview;
+  __pyx_v_dst.memview = __pyx_t_4;
+
+  /* "View.MemoryView":736
+ * 
+ *     dst.memview = p_src.memview
+ *     dst.data = p_src.data             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_5 = __pyx_v_p_src->data;
+  __pyx_v_dst.data = __pyx_t_5;
+
+  /* "View.MemoryView":741
+ * 
+ * 
+ *     cdef __Pyx_memviewslice *p_dst = &dst             # <<<<<<<<<<<<<<
+ *     cdef int *p_suboffset_dim = &suboffset_dim
+ *     cdef Py_ssize_t start, stop, step
+ */
+  __pyx_v_p_dst = (&__pyx_v_dst);
+
+  /* "View.MemoryView":742
+ * 
+ *     cdef __Pyx_memviewslice *p_dst = &dst
+ *     cdef int *p_suboffset_dim = &suboffset_dim             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t start, stop, step
+ *     cdef bint have_start, have_stop, have_step
+ */
+  __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim);
+
+  /* "View.MemoryView":746
+ *     cdef bint have_start, have_stop, have_step
+ * 
+ *     for dim, index in enumerate(indices):             # <<<<<<<<<<<<<<
+ *         if PyIndex_Check(index):
+ *             slice_memviewslice(
+ */
+  __pyx_t_6 = 0;
+  if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) {
+    __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0;
+    __pyx_t_8 = NULL;
+  } else {
+    __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 746, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 746, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_8)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(2, 746, __pyx_L1_error)
+        #else
+        __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 746, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        #endif
+      } else {
+        if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(2, 746, __pyx_L1_error)
+        #else
+        __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 746, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        #endif
+      }
+    } else {
+      __pyx_t_9 = __pyx_t_8(__pyx_t_3);
+      if (unlikely(!__pyx_t_9)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(2, 746, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_9);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9);
+    __pyx_t_9 = 0;
+    __pyx_v_dim = __pyx_t_6;
+    __pyx_t_6 = (__pyx_t_6 + 1);
+
+    /* "View.MemoryView":747
+ * 
+ *     for dim, index in enumerate(indices):
+ *         if PyIndex_Check(index):             # <<<<<<<<<<<<<<
+ *             slice_memviewslice(
+ *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
+ */
+    __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":751
+ *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
+ *                 dim, new_ndim, p_suboffset_dim,
+ *                 index, 0, 0, # start, stop, step             # <<<<<<<<<<<<<<
+ *                 0, 0, 0, # have_{start,stop,step}
+ *                 False)
+ */
+      __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 751, __pyx_L1_error)
+
+      /* "View.MemoryView":748
+ *     for dim, index in enumerate(indices):
+ *         if PyIndex_Check(index):
+ *             slice_memviewslice(             # <<<<<<<<<<<<<<
+ *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
+ *                 dim, new_ndim, p_suboffset_dim,
+ */
+      __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 748, __pyx_L1_error)
+
+      /* "View.MemoryView":747
+ * 
+ *     for dim, index in enumerate(indices):
+ *         if PyIndex_Check(index):             # <<<<<<<<<<<<<<
+ *             slice_memviewslice(
+ *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
+ */
+      goto __pyx_L6;
+    }
+
+    /* "View.MemoryView":754
+ *                 0, 0, 0, # have_{start,stop,step}
+ *                 False)
+ *         elif index is None:             # <<<<<<<<<<<<<<
+ *             p_dst.shape[new_ndim] = 1
+ *             p_dst.strides[new_ndim] = 0
+ */
+    __pyx_t_2 = (__pyx_v_index == Py_None);
+    __pyx_t_1 = (__pyx_t_2 != 0);
+    if (__pyx_t_1) {
+
+      /* "View.MemoryView":755
+ *                 False)
+ *         elif index is None:
+ *             p_dst.shape[new_ndim] = 1             # <<<<<<<<<<<<<<
+ *             p_dst.strides[new_ndim] = 0
+ *             p_dst.suboffsets[new_ndim] = -1
+ */
+      (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1;
+
+      /* "View.MemoryView":756
+ *         elif index is None:
+ *             p_dst.shape[new_ndim] = 1
+ *             p_dst.strides[new_ndim] = 0             # <<<<<<<<<<<<<<
+ *             p_dst.suboffsets[new_ndim] = -1
+ *             new_ndim += 1
+ */
+      (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0;
+
+      /* "View.MemoryView":757
+ *             p_dst.shape[new_ndim] = 1
+ *             p_dst.strides[new_ndim] = 0
+ *             p_dst.suboffsets[new_ndim] = -1             # <<<<<<<<<<<<<<
+ *             new_ndim += 1
+ *         else:
+ */
+      (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L;
+
+      /* "View.MemoryView":758
+ *             p_dst.strides[new_ndim] = 0
+ *             p_dst.suboffsets[new_ndim] = -1
+ *             new_ndim += 1             # <<<<<<<<<<<<<<
+ *         else:
+ *             start = index.start or 0
+ */
+      __pyx_v_new_ndim = (__pyx_v_new_ndim + 1);
+
+      /* "View.MemoryView":754
+ *                 0, 0, 0, # have_{start,stop,step}
+ *                 False)
+ *         elif index is None:             # <<<<<<<<<<<<<<
+ *             p_dst.shape[new_ndim] = 1
+ *             p_dst.strides[new_ndim] = 0
+ */
+      goto __pyx_L6;
+    }
+
+    /* "View.MemoryView":760
+ *             new_ndim += 1
+ *         else:
+ *             start = index.start or 0             # <<<<<<<<<<<<<<
+ *             stop = index.stop or 0
+ *             step = index.step or 0
+ */
+    /*else*/ {
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 760, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 760, __pyx_L1_error)
+      if (!__pyx_t_1) {
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      } else {
+        __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 760, __pyx_L1_error)
+        __pyx_t_10 = __pyx_t_12;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        goto __pyx_L7_bool_binop_done;
+      }
+      __pyx_t_10 = 0;
+      __pyx_L7_bool_binop_done:;
+      __pyx_v_start = __pyx_t_10;
+
+      /* "View.MemoryView":761
+ *         else:
+ *             start = index.start or 0
+ *             stop = index.stop or 0             # <<<<<<<<<<<<<<
+ *             step = index.step or 0
+ * 
+ */
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 761, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 761, __pyx_L1_error)
+      if (!__pyx_t_1) {
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      } else {
+        __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 761, __pyx_L1_error)
+        __pyx_t_10 = __pyx_t_12;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        goto __pyx_L9_bool_binop_done;
+      }
+      __pyx_t_10 = 0;
+      __pyx_L9_bool_binop_done:;
+      __pyx_v_stop = __pyx_t_10;
+
+      /* "View.MemoryView":762
+ *             start = index.start or 0
+ *             stop = index.stop or 0
+ *             step = index.step or 0             # <<<<<<<<<<<<<<
+ * 
+ *             have_start = index.start is not None
+ */
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 762, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 762, __pyx_L1_error)
+      if (!__pyx_t_1) {
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      } else {
+        __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 762, __pyx_L1_error)
+        __pyx_t_10 = __pyx_t_12;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        goto __pyx_L11_bool_binop_done;
+      }
+      __pyx_t_10 = 0;
+      __pyx_L11_bool_binop_done:;
+      __pyx_v_step = __pyx_t_10;
+
+      /* "View.MemoryView":764
+ *             step = index.step or 0
+ * 
+ *             have_start = index.start is not None             # <<<<<<<<<<<<<<
+ *             have_stop = index.stop is not None
+ *             have_step = index.step is not None
+ */
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 764, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_1 = (__pyx_t_9 != Py_None);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_v_have_start = __pyx_t_1;
+
+      /* "View.MemoryView":765
+ * 
+ *             have_start = index.start is not None
+ *             have_stop = index.stop is not None             # <<<<<<<<<<<<<<
+ *             have_step = index.step is not None
+ * 
+ */
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 765, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_1 = (__pyx_t_9 != Py_None);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_v_have_stop = __pyx_t_1;
+
+      /* "View.MemoryView":766
+ *             have_start = index.start is not None
+ *             have_stop = index.stop is not None
+ *             have_step = index.step is not None             # <<<<<<<<<<<<<<
+ * 
+ *             slice_memviewslice(
+ */
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 766, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_1 = (__pyx_t_9 != Py_None);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_v_have_step = __pyx_t_1;
+
+      /* "View.MemoryView":768
+ *             have_step = index.step is not None
+ * 
+ *             slice_memviewslice(             # <<<<<<<<<<<<<<
+ *                 p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
+ *                 dim, new_ndim, p_suboffset_dim,
+ */
+      __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 768, __pyx_L1_error)
+
+      /* "View.MemoryView":774
+ *                 have_start, have_stop, have_step,
+ *                 True)
+ *             new_ndim += 1             # <<<<<<<<<<<<<<
+ * 
+ *     if isinstance(memview, _memoryviewslice):
+ */
+      __pyx_v_new_ndim = (__pyx_v_new_ndim + 1);
+    }
+    __pyx_L6:;
+
+    /* "View.MemoryView":746
+ *     cdef bint have_start, have_stop, have_step
+ * 
+ *     for dim, index in enumerate(indices):             # <<<<<<<<<<<<<<
+ *         if PyIndex_Check(index):
+ *             slice_memviewslice(
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "View.MemoryView":776
+ *             new_ndim += 1
+ * 
+ *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
+ *         return memoryview_fromslice(dst, new_ndim,
+ *                                     memviewsliceobj.to_object_func,
+ */
+  __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":777
+ * 
+ *     if isinstance(memview, _memoryviewslice):
+ *         return memoryview_fromslice(dst, new_ndim,             # <<<<<<<<<<<<<<
+ *                                     memviewsliceobj.to_object_func,
+ *                                     memviewsliceobj.to_dtype_func,
+ */
+    __Pyx_XDECREF(((PyObject *)__pyx_r));
+
+    /* "View.MemoryView":778
+ *     if isinstance(memview, _memoryviewslice):
+ *         return memoryview_fromslice(dst, new_ndim,
+ *                                     memviewsliceobj.to_object_func,             # <<<<<<<<<<<<<<
+ *                                     memviewsliceobj.to_dtype_func,
+ *                                     memview.dtype_is_object)
+ */
+    if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(2, 778, __pyx_L1_error) }
+
+    /* "View.MemoryView":779
+ *         return memoryview_fromslice(dst, new_ndim,
+ *                                     memviewsliceobj.to_object_func,
+ *                                     memviewsliceobj.to_dtype_func,             # <<<<<<<<<<<<<<
+ *                                     memview.dtype_is_object)
+ *     else:
+ */
+    if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(2, 779, __pyx_L1_error) }
+
+    /* "View.MemoryView":777
+ * 
+ *     if isinstance(memview, _memoryviewslice):
+ *         return memoryview_fromslice(dst, new_ndim,             # <<<<<<<<<<<<<<
+ *                                     memviewsliceobj.to_object_func,
+ *                                     memviewsliceobj.to_dtype_func,
+ */
+    __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 777, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(2, 777, __pyx_L1_error)
+    __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3);
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+
+    /* "View.MemoryView":776
+ *             new_ndim += 1
+ * 
+ *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
+ *         return memoryview_fromslice(dst, new_ndim,
+ *                                     memviewsliceobj.to_object_func,
+ */
+  }
+
+  /* "View.MemoryView":782
+ *                                     memview.dtype_is_object)
+ *     else:
+ *         return memoryview_fromslice(dst, new_ndim, NULL, NULL,             # <<<<<<<<<<<<<<
+ *                                     memview.dtype_is_object)
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(((PyObject *)__pyx_r));
+
+    /* "View.MemoryView":783
+ *     else:
+ *         return memoryview_fromslice(dst, new_ndim, NULL, NULL,
+ *                                     memview.dtype_is_object)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 782, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+
+    /* "View.MemoryView":782
+ *                                     memview.dtype_is_object)
+ *     else:
+ *         return memoryview_fromslice(dst, new_ndim, NULL, NULL,             # <<<<<<<<<<<<<<
+ *                                     memview.dtype_is_object)
+ * 
+ */
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(2, 782, __pyx_L1_error)
+    __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3);
+    __pyx_t_3 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "View.MemoryView":710
+ * 
+ * @cname('__pyx_memview_slice')
+ * cdef memoryview memview_slice(memoryview memview, object indices):             # <<<<<<<<<<<<<<
+ *     cdef int new_ndim = 0, suboffset_dim = -1, dim
+ *     cdef bint negative_step
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj);
+  __Pyx_XDECREF(__pyx_v_index);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":807
+ * 
+ * @cname('__pyx_memoryview_slice_memviewslice')
+ * cdef int slice_memviewslice(             # <<<<<<<<<<<<<<
+ *         __Pyx_memviewslice *dst,
+ *         Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
+ */
+
+static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) {
+  Py_ssize_t __pyx_v_new_shape;
+  int __pyx_v_negative_step;
+  int __pyx_r;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* "View.MemoryView":827
+ *     cdef bint negative_step
+ * 
+ *     if not is_slice:             # <<<<<<<<<<<<<<
+ * 
+ *         if start < 0:
+ */
+  __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":829
+ *     if not is_slice:
+ * 
+ *         if start < 0:             # <<<<<<<<<<<<<<
+ *             start += shape
+ *         if not 0 <= start < shape:
+ */
+    __pyx_t_1 = ((__pyx_v_start < 0) != 0);
+    if (__pyx_t_1) {
+
+      /* "View.MemoryView":830
+ * 
+ *         if start < 0:
+ *             start += shape             # <<<<<<<<<<<<<<
+ *         if not 0 <= start < shape:
+ *             _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
+ */
+      __pyx_v_start = (__pyx_v_start + __pyx_v_shape);
+
+      /* "View.MemoryView":829
+ *     if not is_slice:
+ * 
+ *         if start < 0:             # <<<<<<<<<<<<<<
+ *             start += shape
+ *         if not 0 <= start < shape:
+ */
+    }
+
+    /* "View.MemoryView":831
+ *         if start < 0:
+ *             start += shape
+ *         if not 0 <= start < shape:             # <<<<<<<<<<<<<<
+ *             _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
+ *     else:
+ */
+    __pyx_t_1 = (0 <= __pyx_v_start);
+    if (__pyx_t_1) {
+      __pyx_t_1 = (__pyx_v_start < __pyx_v_shape);
+    }
+    __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":832
+ *             start += shape
+ *         if not 0 <= start < shape:
+ *             _err_dim(IndexError, "Index out of bounds (axis %d)", dim)             # <<<<<<<<<<<<<<
+ *     else:
+ * 
+ */
+      __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 832, __pyx_L1_error)
+
+      /* "View.MemoryView":831
+ *         if start < 0:
+ *             start += shape
+ *         if not 0 <= start < shape:             # <<<<<<<<<<<<<<
+ *             _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
+ *     else:
+ */
+    }
+
+    /* "View.MemoryView":827
+ *     cdef bint negative_step
+ * 
+ *     if not is_slice:             # <<<<<<<<<<<<<<
+ * 
+ *         if start < 0:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":835
+ *     else:
+ * 
+ *         negative_step = have_step != 0 and step < 0             # <<<<<<<<<<<<<<
+ * 
+ *         if have_step and step == 0:
+ */
+  /*else*/ {
+    __pyx_t_1 = ((__pyx_v_have_step != 0) != 0);
+    if (__pyx_t_1) {
+    } else {
+      __pyx_t_2 = __pyx_t_1;
+      goto __pyx_L6_bool_binop_done;
+    }
+    __pyx_t_1 = ((__pyx_v_step < 0) != 0);
+    __pyx_t_2 = __pyx_t_1;
+    __pyx_L6_bool_binop_done:;
+    __pyx_v_negative_step = __pyx_t_2;
+
+    /* "View.MemoryView":837
+ *         negative_step = have_step != 0 and step < 0
+ * 
+ *         if have_step and step == 0:             # <<<<<<<<<<<<<<
+ *             _err_dim(ValueError, "Step may not be zero (axis %d)", dim)
+ * 
+ */
+    __pyx_t_1 = (__pyx_v_have_step != 0);
+    if (__pyx_t_1) {
+    } else {
+      __pyx_t_2 = __pyx_t_1;
+      goto __pyx_L9_bool_binop_done;
+    }
+    __pyx_t_1 = ((__pyx_v_step == 0) != 0);
+    __pyx_t_2 = __pyx_t_1;
+    __pyx_L9_bool_binop_done:;
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":838
+ * 
+ *         if have_step and step == 0:
+ *             _err_dim(ValueError, "Step may not be zero (axis %d)", dim)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+      __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 838, __pyx_L1_error)
+
+      /* "View.MemoryView":837
+ *         negative_step = have_step != 0 and step < 0
+ * 
+ *         if have_step and step == 0:             # <<<<<<<<<<<<<<
+ *             _err_dim(ValueError, "Step may not be zero (axis %d)", dim)
+ * 
+ */
+    }
+
+    /* "View.MemoryView":841
+ * 
+ * 
+ *         if have_start:             # <<<<<<<<<<<<<<
+ *             if start < 0:
+ *                 start += shape
+ */
+    __pyx_t_2 = (__pyx_v_have_start != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":842
+ * 
+ *         if have_start:
+ *             if start < 0:             # <<<<<<<<<<<<<<
+ *                 start += shape
+ *                 if start < 0:
+ */
+      __pyx_t_2 = ((__pyx_v_start < 0) != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":843
+ *         if have_start:
+ *             if start < 0:
+ *                 start += shape             # <<<<<<<<<<<<<<
+ *                 if start < 0:
+ *                     start = 0
+ */
+        __pyx_v_start = (__pyx_v_start + __pyx_v_shape);
+
+        /* "View.MemoryView":844
+ *             if start < 0:
+ *                 start += shape
+ *                 if start < 0:             # <<<<<<<<<<<<<<
+ *                     start = 0
+ *             elif start >= shape:
+ */
+        __pyx_t_2 = ((__pyx_v_start < 0) != 0);
+        if (__pyx_t_2) {
+
+          /* "View.MemoryView":845
+ *                 start += shape
+ *                 if start < 0:
+ *                     start = 0             # <<<<<<<<<<<<<<
+ *             elif start >= shape:
+ *                 if negative_step:
+ */
+          __pyx_v_start = 0;
+
+          /* "View.MemoryView":844
+ *             if start < 0:
+ *                 start += shape
+ *                 if start < 0:             # <<<<<<<<<<<<<<
+ *                     start = 0
+ *             elif start >= shape:
+ */
+        }
+
+        /* "View.MemoryView":842
+ * 
+ *         if have_start:
+ *             if start < 0:             # <<<<<<<<<<<<<<
+ *                 start += shape
+ *                 if start < 0:
+ */
+        goto __pyx_L12;
+      }
+
+      /* "View.MemoryView":846
+ *                 if start < 0:
+ *                     start = 0
+ *             elif start >= shape:             # <<<<<<<<<<<<<<
+ *                 if negative_step:
+ *                     start = shape - 1
+ */
+      __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":847
+ *                     start = 0
+ *             elif start >= shape:
+ *                 if negative_step:             # <<<<<<<<<<<<<<
+ *                     start = shape - 1
+ *                 else:
+ */
+        __pyx_t_2 = (__pyx_v_negative_step != 0);
+        if (__pyx_t_2) {
+
+          /* "View.MemoryView":848
+ *             elif start >= shape:
+ *                 if negative_step:
+ *                     start = shape - 1             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     start = shape
+ */
+          __pyx_v_start = (__pyx_v_shape - 1);
+
+          /* "View.MemoryView":847
+ *                     start = 0
+ *             elif start >= shape:
+ *                 if negative_step:             # <<<<<<<<<<<<<<
+ *                     start = shape - 1
+ *                 else:
+ */
+          goto __pyx_L14;
+        }
+
+        /* "View.MemoryView":850
+ *                     start = shape - 1
+ *                 else:
+ *                     start = shape             # <<<<<<<<<<<<<<
+ *         else:
+ *             if negative_step:
+ */
+        /*else*/ {
+          __pyx_v_start = __pyx_v_shape;
+        }
+        __pyx_L14:;
+
+        /* "View.MemoryView":846
+ *                 if start < 0:
+ *                     start = 0
+ *             elif start >= shape:             # <<<<<<<<<<<<<<
+ *                 if negative_step:
+ *                     start = shape - 1
+ */
+      }
+      __pyx_L12:;
+
+      /* "View.MemoryView":841
+ * 
+ * 
+ *         if have_start:             # <<<<<<<<<<<<<<
+ *             if start < 0:
+ *                 start += shape
+ */
+      goto __pyx_L11;
+    }
+
+    /* "View.MemoryView":852
+ *                     start = shape
+ *         else:
+ *             if negative_step:             # <<<<<<<<<<<<<<
+ *                 start = shape - 1
+ *             else:
+ */
+    /*else*/ {
+      __pyx_t_2 = (__pyx_v_negative_step != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":853
+ *         else:
+ *             if negative_step:
+ *                 start = shape - 1             # <<<<<<<<<<<<<<
+ *             else:
+ *                 start = 0
+ */
+        __pyx_v_start = (__pyx_v_shape - 1);
+
+        /* "View.MemoryView":852
+ *                     start = shape
+ *         else:
+ *             if negative_step:             # <<<<<<<<<<<<<<
+ *                 start = shape - 1
+ *             else:
+ */
+        goto __pyx_L15;
+      }
+
+      /* "View.MemoryView":855
+ *                 start = shape - 1
+ *             else:
+ *                 start = 0             # <<<<<<<<<<<<<<
+ * 
+ *         if have_stop:
+ */
+      /*else*/ {
+        __pyx_v_start = 0;
+      }
+      __pyx_L15:;
+    }
+    __pyx_L11:;
+
+    /* "View.MemoryView":857
+ *                 start = 0
+ * 
+ *         if have_stop:             # <<<<<<<<<<<<<<
+ *             if stop < 0:
+ *                 stop += shape
+ */
+    __pyx_t_2 = (__pyx_v_have_stop != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":858
+ * 
+ *         if have_stop:
+ *             if stop < 0:             # <<<<<<<<<<<<<<
+ *                 stop += shape
+ *                 if stop < 0:
+ */
+      __pyx_t_2 = ((__pyx_v_stop < 0) != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":859
+ *         if have_stop:
+ *             if stop < 0:
+ *                 stop += shape             # <<<<<<<<<<<<<<
+ *                 if stop < 0:
+ *                     stop = 0
+ */
+        __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape);
+
+        /* "View.MemoryView":860
+ *             if stop < 0:
+ *                 stop += shape
+ *                 if stop < 0:             # <<<<<<<<<<<<<<
+ *                     stop = 0
+ *             elif stop > shape:
+ */
+        __pyx_t_2 = ((__pyx_v_stop < 0) != 0);
+        if (__pyx_t_2) {
+
+          /* "View.MemoryView":861
+ *                 stop += shape
+ *                 if stop < 0:
+ *                     stop = 0             # <<<<<<<<<<<<<<
+ *             elif stop > shape:
+ *                 stop = shape
+ */
+          __pyx_v_stop = 0;
+
+          /* "View.MemoryView":860
+ *             if stop < 0:
+ *                 stop += shape
+ *                 if stop < 0:             # <<<<<<<<<<<<<<
+ *                     stop = 0
+ *             elif stop > shape:
+ */
+        }
+
+        /* "View.MemoryView":858
+ * 
+ *         if have_stop:
+ *             if stop < 0:             # <<<<<<<<<<<<<<
+ *                 stop += shape
+ *                 if stop < 0:
+ */
+        goto __pyx_L17;
+      }
+
+      /* "View.MemoryView":862
+ *                 if stop < 0:
+ *                     stop = 0
+ *             elif stop > shape:             # <<<<<<<<<<<<<<
+ *                 stop = shape
+ *         else:
+ */
+      __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":863
+ *                     stop = 0
+ *             elif stop > shape:
+ *                 stop = shape             # <<<<<<<<<<<<<<
+ *         else:
+ *             if negative_step:
+ */
+        __pyx_v_stop = __pyx_v_shape;
+
+        /* "View.MemoryView":862
+ *                 if stop < 0:
+ *                     stop = 0
+ *             elif stop > shape:             # <<<<<<<<<<<<<<
+ *                 stop = shape
+ *         else:
+ */
+      }
+      __pyx_L17:;
+
+      /* "View.MemoryView":857
+ *                 start = 0
+ * 
+ *         if have_stop:             # <<<<<<<<<<<<<<
+ *             if stop < 0:
+ *                 stop += shape
+ */
+      goto __pyx_L16;
+    }
+
+    /* "View.MemoryView":865
+ *                 stop = shape
+ *         else:
+ *             if negative_step:             # <<<<<<<<<<<<<<
+ *                 stop = -1
+ *             else:
+ */
+    /*else*/ {
+      __pyx_t_2 = (__pyx_v_negative_step != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":866
+ *         else:
+ *             if negative_step:
+ *                 stop = -1             # <<<<<<<<<<<<<<
+ *             else:
+ *                 stop = shape
+ */
+        __pyx_v_stop = -1L;
+
+        /* "View.MemoryView":865
+ *                 stop = shape
+ *         else:
+ *             if negative_step:             # <<<<<<<<<<<<<<
+ *                 stop = -1
+ *             else:
+ */
+        goto __pyx_L19;
+      }
+
+      /* "View.MemoryView":868
+ *                 stop = -1
+ *             else:
+ *                 stop = shape             # <<<<<<<<<<<<<<
+ * 
+ *         if not have_step:
+ */
+      /*else*/ {
+        __pyx_v_stop = __pyx_v_shape;
+      }
+      __pyx_L19:;
+    }
+    __pyx_L16:;
+
+    /* "View.MemoryView":870
+ *                 stop = shape
+ * 
+ *         if not have_step:             # <<<<<<<<<<<<<<
+ *             step = 1
+ * 
+ */
+    __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":871
+ * 
+ *         if not have_step:
+ *             step = 1             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+      __pyx_v_step = 1;
+
+      /* "View.MemoryView":870
+ *                 stop = shape
+ * 
+ *         if not have_step:             # <<<<<<<<<<<<<<
+ *             step = 1
+ * 
+ */
+    }
+
+    /* "View.MemoryView":875
+ * 
+ *         with cython.cdivision(True):
+ *             new_shape = (stop - start) // step             # <<<<<<<<<<<<<<
+ * 
+ *             if (stop - start) - step * new_shape:
+ */
+    __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step);
+
+    /* "View.MemoryView":877
+ *             new_shape = (stop - start) // step
+ * 
+ *             if (stop - start) - step * new_shape:             # <<<<<<<<<<<<<<
+ *                 new_shape += 1
+ * 
+ */
+    __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":878
+ * 
+ *             if (stop - start) - step * new_shape:
+ *                 new_shape += 1             # <<<<<<<<<<<<<<
+ * 
+ *         if new_shape < 0:
+ */
+      __pyx_v_new_shape = (__pyx_v_new_shape + 1);
+
+      /* "View.MemoryView":877
+ *             new_shape = (stop - start) // step
+ * 
+ *             if (stop - start) - step * new_shape:             # <<<<<<<<<<<<<<
+ *                 new_shape += 1
+ * 
+ */
+    }
+
+    /* "View.MemoryView":880
+ *                 new_shape += 1
+ * 
+ *         if new_shape < 0:             # <<<<<<<<<<<<<<
+ *             new_shape = 0
+ * 
+ */
+    __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":881
+ * 
+ *         if new_shape < 0:
+ *             new_shape = 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+      __pyx_v_new_shape = 0;
+
+      /* "View.MemoryView":880
+ *                 new_shape += 1
+ * 
+ *         if new_shape < 0:             # <<<<<<<<<<<<<<
+ *             new_shape = 0
+ * 
+ */
+    }
+
+    /* "View.MemoryView":884
+ * 
+ * 
+ *         dst.strides[new_ndim] = stride * step             # <<<<<<<<<<<<<<
+ *         dst.shape[new_ndim] = new_shape
+ *         dst.suboffsets[new_ndim] = suboffset
+ */
+    (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step);
+
+    /* "View.MemoryView":885
+ * 
+ *         dst.strides[new_ndim] = stride * step
+ *         dst.shape[new_ndim] = new_shape             # <<<<<<<<<<<<<<
+ *         dst.suboffsets[new_ndim] = suboffset
+ * 
+ */
+    (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape;
+
+    /* "View.MemoryView":886
+ *         dst.strides[new_ndim] = stride * step
+ *         dst.shape[new_ndim] = new_shape
+ *         dst.suboffsets[new_ndim] = suboffset             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset;
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":889
+ * 
+ * 
+ *     if suboffset_dim[0] < 0:             # <<<<<<<<<<<<<<
+ *         dst.data += start * stride
+ *     else:
+ */
+  __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":890
+ * 
+ *     if suboffset_dim[0] < 0:
+ *         dst.data += start * stride             # <<<<<<<<<<<<<<
+ *     else:
+ *         dst.suboffsets[suboffset_dim[0]] += start * stride
+ */
+    __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride));
+
+    /* "View.MemoryView":889
+ * 
+ * 
+ *     if suboffset_dim[0] < 0:             # <<<<<<<<<<<<<<
+ *         dst.data += start * stride
+ *     else:
+ */
+    goto __pyx_L23;
+  }
+
+  /* "View.MemoryView":892
+ *         dst.data += start * stride
+ *     else:
+ *         dst.suboffsets[suboffset_dim[0]] += start * stride             # <<<<<<<<<<<<<<
+ * 
+ *     if suboffset >= 0:
+ */
+  /*else*/ {
+    __pyx_t_3 = (__pyx_v_suboffset_dim[0]);
+    (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride));
+  }
+  __pyx_L23:;
+
+  /* "View.MemoryView":894
+ *         dst.suboffsets[suboffset_dim[0]] += start * stride
+ * 
+ *     if suboffset >= 0:             # <<<<<<<<<<<<<<
+ *         if not is_slice:
+ *             if new_ndim == 0:
+ */
+  __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":895
+ * 
+ *     if suboffset >= 0:
+ *         if not is_slice:             # <<<<<<<<<<<<<<
+ *             if new_ndim == 0:
+ *                 dst.data = ( dst.data)[0] + suboffset
+ */
+    __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":896
+ *     if suboffset >= 0:
+ *         if not is_slice:
+ *             if new_ndim == 0:             # <<<<<<<<<<<<<<
+ *                 dst.data = ( dst.data)[0] + suboffset
+ *             else:
+ */
+      __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":897
+ *         if not is_slice:
+ *             if new_ndim == 0:
+ *                 dst.data = ( dst.data)[0] + suboffset             # <<<<<<<<<<<<<<
+ *             else:
+ *                 _err_dim(IndexError, "All dimensions preceding dimension %d "
+ */
+        __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset);
+
+        /* "View.MemoryView":896
+ *     if suboffset >= 0:
+ *         if not is_slice:
+ *             if new_ndim == 0:             # <<<<<<<<<<<<<<
+ *                 dst.data = ( dst.data)[0] + suboffset
+ *             else:
+ */
+        goto __pyx_L26;
+      }
+
+      /* "View.MemoryView":899
+ *                 dst.data = ( dst.data)[0] + suboffset
+ *             else:
+ *                 _err_dim(IndexError, "All dimensions preceding dimension %d "             # <<<<<<<<<<<<<<
+ *                                      "must be indexed and not sliced", dim)
+ *         else:
+ */
+      /*else*/ {
+
+        /* "View.MemoryView":900
+ *             else:
+ *                 _err_dim(IndexError, "All dimensions preceding dimension %d "
+ *                                      "must be indexed and not sliced", dim)             # <<<<<<<<<<<<<<
+ *         else:
+ *             suboffset_dim[0] = new_ndim
+ */
+        __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 899, __pyx_L1_error)
+      }
+      __pyx_L26:;
+
+      /* "View.MemoryView":895
+ * 
+ *     if suboffset >= 0:
+ *         if not is_slice:             # <<<<<<<<<<<<<<
+ *             if new_ndim == 0:
+ *                 dst.data = ( dst.data)[0] + suboffset
+ */
+      goto __pyx_L25;
+    }
+
+    /* "View.MemoryView":902
+ *                                      "must be indexed and not sliced", dim)
+ *         else:
+ *             suboffset_dim[0] = new_ndim             # <<<<<<<<<<<<<<
+ * 
+ *     return 0
+ */
+    /*else*/ {
+      (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim;
+    }
+    __pyx_L25:;
+
+    /* "View.MemoryView":894
+ *         dst.suboffsets[suboffset_dim[0]] += start * stride
+ * 
+ *     if suboffset >= 0:             # <<<<<<<<<<<<<<
+ *         if not is_slice:
+ *             if new_ndim == 0:
+ */
+  }
+
+  /* "View.MemoryView":904
+ *             suboffset_dim[0] = new_ndim
+ * 
+ *     return 0             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":807
+ * 
+ * @cname('__pyx_memoryview_slice_memviewslice')
+ * cdef int slice_memviewslice(             # <<<<<<<<<<<<<<
+ *         __Pyx_memviewslice *dst,
+ *         Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  {
+    #ifdef WITH_THREAD
+    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+    #endif
+    __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    #ifdef WITH_THREAD
+    __Pyx_PyGILState_Release(__pyx_gilstate_save);
+    #endif
+  }
+  __pyx_r = -1;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":910
+ * 
+ * @cname('__pyx_pybuffer_index')
+ * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,             # <<<<<<<<<<<<<<
+ *                           Py_ssize_t dim) except NULL:
+ *     cdef Py_ssize_t shape, stride, suboffset = -1
+ */
+
+static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) {
+  Py_ssize_t __pyx_v_shape;
+  Py_ssize_t __pyx_v_stride;
+  Py_ssize_t __pyx_v_suboffset;
+  Py_ssize_t __pyx_v_itemsize;
+  char *__pyx_v_resultp;
+  char *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("pybuffer_index", 0);
+
+  /* "View.MemoryView":912
+ * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,
+ *                           Py_ssize_t dim) except NULL:
+ *     cdef Py_ssize_t shape, stride, suboffset = -1             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t itemsize = view.itemsize
+ *     cdef char *resultp
+ */
+  __pyx_v_suboffset = -1L;
+
+  /* "View.MemoryView":913
+ *                           Py_ssize_t dim) except NULL:
+ *     cdef Py_ssize_t shape, stride, suboffset = -1
+ *     cdef Py_ssize_t itemsize = view.itemsize             # <<<<<<<<<<<<<<
+ *     cdef char *resultp
+ * 
+ */
+  __pyx_t_1 = __pyx_v_view->itemsize;
+  __pyx_v_itemsize = __pyx_t_1;
+
+  /* "View.MemoryView":916
+ *     cdef char *resultp
+ * 
+ *     if view.ndim == 0:             # <<<<<<<<<<<<<<
+ *         shape = view.len / itemsize
+ *         stride = itemsize
+ */
+  __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":917
+ * 
+ *     if view.ndim == 0:
+ *         shape = view.len / itemsize             # <<<<<<<<<<<<<<
+ *         stride = itemsize
+ *     else:
+ */
+    if (unlikely(__pyx_v_itemsize == 0)) {
+      PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
+      __PYX_ERR(2, 917, __pyx_L1_error)
+    }
+    else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1)  && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) {
+      PyErr_SetString(PyExc_OverflowError, "value too large to perform division");
+      __PYX_ERR(2, 917, __pyx_L1_error)
+    }
+    __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize);
+
+    /* "View.MemoryView":918
+ *     if view.ndim == 0:
+ *         shape = view.len / itemsize
+ *         stride = itemsize             # <<<<<<<<<<<<<<
+ *     else:
+ *         shape = view.shape[dim]
+ */
+    __pyx_v_stride = __pyx_v_itemsize;
+
+    /* "View.MemoryView":916
+ *     cdef char *resultp
+ * 
+ *     if view.ndim == 0:             # <<<<<<<<<<<<<<
+ *         shape = view.len / itemsize
+ *         stride = itemsize
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":920
+ *         stride = itemsize
+ *     else:
+ *         shape = view.shape[dim]             # <<<<<<<<<<<<<<
+ *         stride = view.strides[dim]
+ *         if view.suboffsets != NULL:
+ */
+  /*else*/ {
+    __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]);
+
+    /* "View.MemoryView":921
+ *     else:
+ *         shape = view.shape[dim]
+ *         stride = view.strides[dim]             # <<<<<<<<<<<<<<
+ *         if view.suboffsets != NULL:
+ *             suboffset = view.suboffsets[dim]
+ */
+    __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]);
+
+    /* "View.MemoryView":922
+ *         shape = view.shape[dim]
+ *         stride = view.strides[dim]
+ *         if view.suboffsets != NULL:             # <<<<<<<<<<<<<<
+ *             suboffset = view.suboffsets[dim]
+ * 
+ */
+    __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":923
+ *         stride = view.strides[dim]
+ *         if view.suboffsets != NULL:
+ *             suboffset = view.suboffsets[dim]             # <<<<<<<<<<<<<<
+ * 
+ *     if index < 0:
+ */
+      __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]);
+
+      /* "View.MemoryView":922
+ *         shape = view.shape[dim]
+ *         stride = view.strides[dim]
+ *         if view.suboffsets != NULL:             # <<<<<<<<<<<<<<
+ *             suboffset = view.suboffsets[dim]
+ * 
+ */
+    }
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":925
+ *             suboffset = view.suboffsets[dim]
+ * 
+ *     if index < 0:             # <<<<<<<<<<<<<<
+ *         index += view.shape[dim]
+ *         if index < 0:
+ */
+  __pyx_t_2 = ((__pyx_v_index < 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":926
+ * 
+ *     if index < 0:
+ *         index += view.shape[dim]             # <<<<<<<<<<<<<<
+ *         if index < 0:
+ *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
+ */
+    __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim]));
+
+    /* "View.MemoryView":927
+ *     if index < 0:
+ *         index += view.shape[dim]
+ *         if index < 0:             # <<<<<<<<<<<<<<
+ *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
+ * 
+ */
+    __pyx_t_2 = ((__pyx_v_index < 0) != 0);
+    if (unlikely(__pyx_t_2)) {
+
+      /* "View.MemoryView":928
+ *         index += view.shape[dim]
+ *         if index < 0:
+ *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)             # <<<<<<<<<<<<<<
+ * 
+ *     if index >= shape:
+ */
+      __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 928, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 928, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 928, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(2, 928, __pyx_L1_error)
+
+      /* "View.MemoryView":927
+ *     if index < 0:
+ *         index += view.shape[dim]
+ *         if index < 0:             # <<<<<<<<<<<<<<
+ *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
+ * 
+ */
+    }
+
+    /* "View.MemoryView":925
+ *             suboffset = view.suboffsets[dim]
+ * 
+ *     if index < 0:             # <<<<<<<<<<<<<<
+ *         index += view.shape[dim]
+ *         if index < 0:
+ */
+  }
+
+  /* "View.MemoryView":930
+ *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
+ * 
+ *     if index >= shape:             # <<<<<<<<<<<<<<
+ *         raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "View.MemoryView":931
+ * 
+ *     if index >= shape:
+ *         raise IndexError("Out of bounds on buffer access (axis %d)" % dim)             # <<<<<<<<<<<<<<
+ * 
+ *     resultp = bufp + index * stride
+ */
+    __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 931, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 931, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 931, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 931, __pyx_L1_error)
+
+    /* "View.MemoryView":930
+ *             raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
+ * 
+ *     if index >= shape:             # <<<<<<<<<<<<<<
+ *         raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
+ * 
+ */
+  }
+
+  /* "View.MemoryView":933
+ *         raise IndexError("Out of bounds on buffer access (axis %d)" % dim)
+ * 
+ *     resultp = bufp + index * stride             # <<<<<<<<<<<<<<
+ *     if suboffset >= 0:
+ *         resultp = ( resultp)[0] + suboffset
+ */
+  __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride));
+
+  /* "View.MemoryView":934
+ * 
+ *     resultp = bufp + index * stride
+ *     if suboffset >= 0:             # <<<<<<<<<<<<<<
+ *         resultp = ( resultp)[0] + suboffset
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":935
+ *     resultp = bufp + index * stride
+ *     if suboffset >= 0:
+ *         resultp = ( resultp)[0] + suboffset             # <<<<<<<<<<<<<<
+ * 
+ *     return resultp
+ */
+    __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset);
+
+    /* "View.MemoryView":934
+ * 
+ *     resultp = bufp + index * stride
+ *     if suboffset >= 0:             # <<<<<<<<<<<<<<
+ *         resultp = ( resultp)[0] + suboffset
+ * 
+ */
+  }
+
+  /* "View.MemoryView":937
+ *         resultp = ( resultp)[0] + suboffset
+ * 
+ *     return resultp             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_resultp;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":910
+ * 
+ * @cname('__pyx_pybuffer_index')
+ * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,             # <<<<<<<<<<<<<<
+ *                           Py_ssize_t dim) except NULL:
+ *     cdef Py_ssize_t shape, stride, suboffset = -1
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":943
+ * 
+ * @cname('__pyx_memslice_transpose')
+ * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0:             # <<<<<<<<<<<<<<
+ *     cdef int ndim = memslice.memview.view.ndim
+ * 
+ */
+
+static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) {
+  int __pyx_v_ndim;
+  Py_ssize_t *__pyx_v_shape;
+  Py_ssize_t *__pyx_v_strides;
+  int __pyx_v_i;
+  int __pyx_v_j;
+  int __pyx_r;
+  int __pyx_t_1;
+  Py_ssize_t *__pyx_t_2;
+  long __pyx_t_3;
+  long __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* "View.MemoryView":944
+ * @cname('__pyx_memslice_transpose')
+ * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0:
+ *     cdef int ndim = memslice.memview.view.ndim             # <<<<<<<<<<<<<<
+ * 
+ *     cdef Py_ssize_t *shape = memslice.shape
+ */
+  __pyx_t_1 = __pyx_v_memslice->memview->view.ndim;
+  __pyx_v_ndim = __pyx_t_1;
+
+  /* "View.MemoryView":946
+ *     cdef int ndim = memslice.memview.view.ndim
+ * 
+ *     cdef Py_ssize_t *shape = memslice.shape             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t *strides = memslice.strides
+ * 
+ */
+  __pyx_t_2 = __pyx_v_memslice->shape;
+  __pyx_v_shape = __pyx_t_2;
+
+  /* "View.MemoryView":947
+ * 
+ *     cdef Py_ssize_t *shape = memslice.shape
+ *     cdef Py_ssize_t *strides = memslice.strides             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __pyx_v_memslice->strides;
+  __pyx_v_strides = __pyx_t_2;
+
+  /* "View.MemoryView":951
+ * 
+ *     cdef int i, j
+ *     for i in range(ndim / 2):             # <<<<<<<<<<<<<<
+ *         j = ndim - 1 - i
+ *         strides[i], strides[j] = strides[j], strides[i]
+ */
+  __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2);
+  __pyx_t_4 = __pyx_t_3;
+  for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) {
+    __pyx_v_i = __pyx_t_1;
+
+    /* "View.MemoryView":952
+ *     cdef int i, j
+ *     for i in range(ndim / 2):
+ *         j = ndim - 1 - i             # <<<<<<<<<<<<<<
+ *         strides[i], strides[j] = strides[j], strides[i]
+ *         shape[i], shape[j] = shape[j], shape[i]
+ */
+    __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i);
+
+    /* "View.MemoryView":953
+ *     for i in range(ndim / 2):
+ *         j = ndim - 1 - i
+ *         strides[i], strides[j] = strides[j], strides[i]             # <<<<<<<<<<<<<<
+ *         shape[i], shape[j] = shape[j], shape[i]
+ * 
+ */
+    __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]);
+    __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]);
+    (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5;
+    (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6;
+
+    /* "View.MemoryView":954
+ *         j = ndim - 1 - i
+ *         strides[i], strides[j] = strides[j], strides[i]
+ *         shape[i], shape[j] = shape[j], shape[i]             # <<<<<<<<<<<<<<
+ * 
+ *         if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
+ */
+    __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]);
+    __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]);
+    (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6;
+    (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5;
+
+    /* "View.MemoryView":956
+ *         shape[i], shape[j] = shape[j], shape[i]
+ * 
+ *         if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:             # <<<<<<<<<<<<<<
+ *             _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
+ * 
+ */
+    __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0);
+    if (!__pyx_t_8) {
+    } else {
+      __pyx_t_7 = __pyx_t_8;
+      goto __pyx_L6_bool_binop_done;
+    }
+    __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0);
+    __pyx_t_7 = __pyx_t_8;
+    __pyx_L6_bool_binop_done:;
+    if (__pyx_t_7) {
+
+      /* "View.MemoryView":957
+ * 
+ *         if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
+ *             _err(ValueError, "Cannot transpose memoryview with indirect dimensions")             # <<<<<<<<<<<<<<
+ * 
+ *     return 1
+ */
+      __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 957, __pyx_L1_error)
+
+      /* "View.MemoryView":956
+ *         shape[i], shape[j] = shape[j], shape[i]
+ * 
+ *         if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:             # <<<<<<<<<<<<<<
+ *             _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
+ * 
+ */
+    }
+  }
+
+  /* "View.MemoryView":959
+ *             _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
+ * 
+ *     return 1             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = 1;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":943
+ * 
+ * @cname('__pyx_memslice_transpose')
+ * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0:             # <<<<<<<<<<<<<<
+ *     cdef int ndim = memslice.memview.view.ndim
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  {
+    #ifdef WITH_THREAD
+    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+    #endif
+    __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    #ifdef WITH_THREAD
+    __Pyx_PyGILState_Release(__pyx_gilstate_save);
+    #endif
+  }
+  __pyx_r = 0;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":976
+ *     cdef int (*to_dtype_func)(char *, object) except 0
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "View.MemoryView":977
+ * 
+ *     def __dealloc__(self):
+ *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef convert_item_to_object(self, char *itemp):
+ */
+  __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1);
+
+  /* "View.MemoryView":976
+ *     cdef int (*to_dtype_func)(char *, object) except 0
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":979
+ *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
+ * 
+ *     cdef convert_item_to_object(self, char *itemp):             # <<<<<<<<<<<<<<
+ *         if self.to_object_func != NULL:
+ *             return self.to_object_func(itemp)
+ */
+
+static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("convert_item_to_object", 0);
+
+  /* "View.MemoryView":980
+ * 
+ *     cdef convert_item_to_object(self, char *itemp):
+ *         if self.to_object_func != NULL:             # <<<<<<<<<<<<<<
+ *             return self.to_object_func(itemp)
+ *         else:
+ */
+  __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":981
+ *     cdef convert_item_to_object(self, char *itemp):
+ *         if self.to_object_func != NULL:
+ *             return self.to_object_func(itemp)             # <<<<<<<<<<<<<<
+ *         else:
+ *             return memoryview.convert_item_to_object(self, itemp)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 981, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
+    goto __pyx_L0;
+
+    /* "View.MemoryView":980
+ * 
+ *     cdef convert_item_to_object(self, char *itemp):
+ *         if self.to_object_func != NULL:             # <<<<<<<<<<<<<<
+ *             return self.to_object_func(itemp)
+ *         else:
+ */
+  }
+
+  /* "View.MemoryView":983
+ *             return self.to_object_func(itemp)
+ *         else:
+ *             return memoryview.convert_item_to_object(self, itemp)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef assign_item_from_object(self, char *itemp, object value):
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 983, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
+    goto __pyx_L0;
+  }
+
+  /* "View.MemoryView":979
+ *         __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
+ * 
+ *     cdef convert_item_to_object(self, char *itemp):             # <<<<<<<<<<<<<<
+ *         if self.to_object_func != NULL:
+ *             return self.to_object_func(itemp)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":985
+ *             return memoryview.convert_item_to_object(self, itemp)
+ * 
+ *     cdef assign_item_from_object(self, char *itemp, object value):             # <<<<<<<<<<<<<<
+ *         if self.to_dtype_func != NULL:
+ *             self.to_dtype_func(itemp, value)
+ */
+
+static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("assign_item_from_object", 0);
+
+  /* "View.MemoryView":986
+ * 
+ *     cdef assign_item_from_object(self, char *itemp, object value):
+ *         if self.to_dtype_func != NULL:             # <<<<<<<<<<<<<<
+ *             self.to_dtype_func(itemp, value)
+ *         else:
+ */
+  __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":987
+ *     cdef assign_item_from_object(self, char *itemp, object value):
+ *         if self.to_dtype_func != NULL:
+ *             self.to_dtype_func(itemp, value)             # <<<<<<<<<<<<<<
+ *         else:
+ *             memoryview.assign_item_from_object(self, itemp, value)
+ */
+    __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(2, 987, __pyx_L1_error)
+
+    /* "View.MemoryView":986
+ * 
+ *     cdef assign_item_from_object(self, char *itemp, object value):
+ *         if self.to_dtype_func != NULL:             # <<<<<<<<<<<<<<
+ *             self.to_dtype_func(itemp, value)
+ *         else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":989
+ *             self.to_dtype_func(itemp, value)
+ *         else:
+ *             memoryview.assign_item_from_object(self, itemp, value)             # <<<<<<<<<<<<<<
+ * 
+ *     @property
+ */
+  /*else*/ {
+    __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 989, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":985
+ *             return memoryview.convert_item_to_object(self, itemp)
+ * 
+ *     cdef assign_item_from_object(self, char *itemp, object value):             # <<<<<<<<<<<<<<
+ *         if self.to_dtype_func != NULL:
+ *             self.to_dtype_func(itemp, value)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":992
+ * 
+ *     @property
+ *     def base(self):             # <<<<<<<<<<<<<<
+ *         return self.from_object
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "View.MemoryView":993
+ *     @property
+ *     def base(self):
+ *         return self.from_object             # <<<<<<<<<<<<<<
+ * 
+ *     __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_self->from_object);
+  __pyx_r = __pyx_v_self->from_object;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":992
+ * 
+ *     @property
+ *     def base(self):             # <<<<<<<<<<<<<<
+ *         return self.from_object
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __PYX_ERR(2, 2, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
+static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+  __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __PYX_ERR(2, 4, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":999
+ * 
+ * @cname('__pyx_memoryview_fromslice')
+ * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice,             # <<<<<<<<<<<<<<
+ *                           int ndim,
+ *                           object (*to_object_func)(char *),
+ */
+
+static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) {
+  struct __pyx_memoryviewslice_obj *__pyx_v_result = 0;
+  Py_ssize_t __pyx_v_suboffset;
+  PyObject *__pyx_v_length = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_TypeInfo *__pyx_t_4;
+  Py_buffer __pyx_t_5;
+  Py_ssize_t *__pyx_t_6;
+  Py_ssize_t *__pyx_t_7;
+  Py_ssize_t *__pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("memoryview_fromslice", 0);
+
+  /* "View.MemoryView":1007
+ *     cdef _memoryviewslice result
+ * 
+ *     if  memviewslice.memview == Py_None:             # <<<<<<<<<<<<<<
+ *         return None
+ * 
+ */
+  __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":1008
+ * 
+ *     if  memviewslice.memview == Py_None:
+ *         return None             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+    /* "View.MemoryView":1007
+ *     cdef _memoryviewslice result
+ * 
+ *     if  memviewslice.memview == Py_None:             # <<<<<<<<<<<<<<
+ *         return None
+ * 
+ */
+  }
+
+  /* "View.MemoryView":1013
+ * 
+ * 
+ *     result = _memoryviewslice(None, 0, dtype_is_object)             # <<<<<<<<<<<<<<
+ * 
+ *     result.from_slice = memviewslice
+ */
+  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1013, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1013, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1013, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "View.MemoryView":1015
+ *     result = _memoryviewslice(None, 0, dtype_is_object)
+ * 
+ *     result.from_slice = memviewslice             # <<<<<<<<<<<<<<
+ *     __PYX_INC_MEMVIEW(&memviewslice, 1)
+ * 
+ */
+  __pyx_v_result->from_slice = __pyx_v_memviewslice;
+
+  /* "View.MemoryView":1016
+ * 
+ *     result.from_slice = memviewslice
+ *     __PYX_INC_MEMVIEW(&memviewslice, 1)             # <<<<<<<<<<<<<<
+ * 
+ *     result.from_object = ( memviewslice.memview).base
+ */
+  __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1);
+
+  /* "View.MemoryView":1018
+ *     __PYX_INC_MEMVIEW(&memviewslice, 1)
+ * 
+ *     result.from_object = ( memviewslice.memview).base             # <<<<<<<<<<<<<<
+ *     result.typeinfo = memviewslice.memview.typeinfo
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1018, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_2);
+  __Pyx_GOTREF(__pyx_v_result->from_object);
+  __Pyx_DECREF(__pyx_v_result->from_object);
+  __pyx_v_result->from_object = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "View.MemoryView":1019
+ * 
+ *     result.from_object = ( memviewslice.memview).base
+ *     result.typeinfo = memviewslice.memview.typeinfo             # <<<<<<<<<<<<<<
+ * 
+ *     result.view = memviewslice.memview.view
+ */
+  __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo;
+  __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4;
+
+  /* "View.MemoryView":1021
+ *     result.typeinfo = memviewslice.memview.typeinfo
+ * 
+ *     result.view = memviewslice.memview.view             # <<<<<<<<<<<<<<
+ *     result.view.buf =  memviewslice.data
+ *     result.view.ndim = ndim
+ */
+  __pyx_t_5 = __pyx_v_memviewslice.memview->view;
+  __pyx_v_result->__pyx_base.view = __pyx_t_5;
+
+  /* "View.MemoryView":1022
+ * 
+ *     result.view = memviewslice.memview.view
+ *     result.view.buf =  memviewslice.data             # <<<<<<<<<<<<<<
+ *     result.view.ndim = ndim
+ *     (<__pyx_buffer *> &result.view).obj = Py_None
+ */
+  __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data);
+
+  /* "View.MemoryView":1023
+ *     result.view = memviewslice.memview.view
+ *     result.view.buf =  memviewslice.data
+ *     result.view.ndim = ndim             # <<<<<<<<<<<<<<
+ *     (<__pyx_buffer *> &result.view).obj = Py_None
+ *     Py_INCREF(Py_None)
+ */
+  __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim;
+
+  /* "View.MemoryView":1024
+ *     result.view.buf =  memviewslice.data
+ *     result.view.ndim = ndim
+ *     (<__pyx_buffer *> &result.view).obj = Py_None             # <<<<<<<<<<<<<<
+ *     Py_INCREF(Py_None)
+ * 
+ */
+  ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None;
+
+  /* "View.MemoryView":1025
+ *     result.view.ndim = ndim
+ *     (<__pyx_buffer *> &result.view).obj = Py_None
+ *     Py_INCREF(Py_None)             # <<<<<<<<<<<<<<
+ * 
+ *     if (memviewslice.memview).flags & PyBUF_WRITABLE:
+ */
+  Py_INCREF(Py_None);
+
+  /* "View.MemoryView":1027
+ *     Py_INCREF(Py_None)
+ * 
+ *     if (memviewslice.memview).flags & PyBUF_WRITABLE:             # <<<<<<<<<<<<<<
+ *         result.flags = PyBUF_RECORDS
+ *     else:
+ */
+  __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":1028
+ * 
+ *     if (memviewslice.memview).flags & PyBUF_WRITABLE:
+ *         result.flags = PyBUF_RECORDS             # <<<<<<<<<<<<<<
+ *     else:
+ *         result.flags = PyBUF_RECORDS_RO
+ */
+    __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS;
+
+    /* "View.MemoryView":1027
+ *     Py_INCREF(Py_None)
+ * 
+ *     if (memviewslice.memview).flags & PyBUF_WRITABLE:             # <<<<<<<<<<<<<<
+ *         result.flags = PyBUF_RECORDS
+ *     else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "View.MemoryView":1030
+ *         result.flags = PyBUF_RECORDS
+ *     else:
+ *         result.flags = PyBUF_RECORDS_RO             # <<<<<<<<<<<<<<
+ * 
+ *     result.view.shape =  result.from_slice.shape
+ */
+  /*else*/ {
+    __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO;
+  }
+  __pyx_L4:;
+
+  /* "View.MemoryView":1032
+ *         result.flags = PyBUF_RECORDS_RO
+ * 
+ *     result.view.shape =  result.from_slice.shape             # <<<<<<<<<<<<<<
+ *     result.view.strides =  result.from_slice.strides
+ * 
+ */
+  __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape);
+
+  /* "View.MemoryView":1033
+ * 
+ *     result.view.shape =  result.from_slice.shape
+ *     result.view.strides =  result.from_slice.strides             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides);
+
+  /* "View.MemoryView":1036
+ * 
+ * 
+ *     result.view.suboffsets = NULL             # <<<<<<<<<<<<<<
+ *     for suboffset in result.from_slice.suboffsets[:ndim]:
+ *         if suboffset >= 0:
+ */
+  __pyx_v_result->__pyx_base.view.suboffsets = NULL;
+
+  /* "View.MemoryView":1037
+ * 
+ *     result.view.suboffsets = NULL
+ *     for suboffset in result.from_slice.suboffsets[:ndim]:             # <<<<<<<<<<<<<<
+ *         if suboffset >= 0:
+ *             result.view.suboffsets =  result.from_slice.suboffsets
+ */
+  __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim);
+  for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) {
+    __pyx_t_6 = __pyx_t_8;
+    __pyx_v_suboffset = (__pyx_t_6[0]);
+
+    /* "View.MemoryView":1038
+ *     result.view.suboffsets = NULL
+ *     for suboffset in result.from_slice.suboffsets[:ndim]:
+ *         if suboffset >= 0:             # <<<<<<<<<<<<<<
+ *             result.view.suboffsets =  result.from_slice.suboffsets
+ *             break
+ */
+    __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0);
+    if (__pyx_t_1) {
+
+      /* "View.MemoryView":1039
+ *     for suboffset in result.from_slice.suboffsets[:ndim]:
+ *         if suboffset >= 0:
+ *             result.view.suboffsets =  result.from_slice.suboffsets             # <<<<<<<<<<<<<<
+ *             break
+ * 
+ */
+      __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets);
+
+      /* "View.MemoryView":1040
+ *         if suboffset >= 0:
+ *             result.view.suboffsets =  result.from_slice.suboffsets
+ *             break             # <<<<<<<<<<<<<<
+ * 
+ *     result.view.len = result.view.itemsize
+ */
+      goto __pyx_L6_break;
+
+      /* "View.MemoryView":1038
+ *     result.view.suboffsets = NULL
+ *     for suboffset in result.from_slice.suboffsets[:ndim]:
+ *         if suboffset >= 0:             # <<<<<<<<<<<<<<
+ *             result.view.suboffsets =  result.from_slice.suboffsets
+ *             break
+ */
+    }
+  }
+  __pyx_L6_break:;
+
+  /* "View.MemoryView":1042
+ *             break
+ * 
+ *     result.view.len = result.view.itemsize             # <<<<<<<<<<<<<<
+ *     for length in result.view.shape[:ndim]:
+ *         result.view.len *= length
+ */
+  __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize;
+  __pyx_v_result->__pyx_base.view.len = __pyx_t_9;
+
+  /* "View.MemoryView":1043
+ * 
+ *     result.view.len = result.view.itemsize
+ *     for length in result.view.shape[:ndim]:             # <<<<<<<<<<<<<<
+ *         result.view.len *= length
+ * 
+ */
+  __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim);
+  for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) {
+    __pyx_t_6 = __pyx_t_8;
+    __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1043, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "View.MemoryView":1044
+ *     result.view.len = result.view.itemsize
+ *     for length in result.view.shape[:ndim]:
+ *         result.view.len *= length             # <<<<<<<<<<<<<<
+ * 
+ *     result.to_object_func = to_object_func
+ */
+    __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1044, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1044, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 1044, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_result->__pyx_base.view.len = __pyx_t_9;
+  }
+
+  /* "View.MemoryView":1046
+ *         result.view.len *= length
+ * 
+ *     result.to_object_func = to_object_func             # <<<<<<<<<<<<<<
+ *     result.to_dtype_func = to_dtype_func
+ * 
+ */
+  __pyx_v_result->to_object_func = __pyx_v_to_object_func;
+
+  /* "View.MemoryView":1047
+ * 
+ *     result.to_object_func = to_object_func
+ *     result.to_dtype_func = to_dtype_func             # <<<<<<<<<<<<<<
+ * 
+ *     return result
+ */
+  __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func;
+
+  /* "View.MemoryView":1049
+ *     result.to_dtype_func = to_dtype_func
+ * 
+ *     return result             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_get_slice_from_memoryview')
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "View.MemoryView":999
+ * 
+ * @cname('__pyx_memoryview_fromslice')
+ * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice,             # <<<<<<<<<<<<<<
+ *                           int ndim,
+ *                           object (*to_object_func)(char *),
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XDECREF(__pyx_v_length);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1052
+ * 
+ * @cname('__pyx_memoryview_get_slice_from_memoryview')
+ * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview,             # <<<<<<<<<<<<<<
+ *                                                    __Pyx_memviewslice *mslice) except NULL:
+ *     cdef _memoryviewslice obj
+ */
+
+static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) {
+  struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0;
+  __Pyx_memviewslice *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_slice_from_memview", 0);
+
+  /* "View.MemoryView":1055
+ *                                                    __Pyx_memviewslice *mslice) except NULL:
+ *     cdef _memoryviewslice obj
+ *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
+ *         obj = memview
+ *         return &obj.from_slice
+ */
+  __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1056
+ *     cdef _memoryviewslice obj
+ *     if isinstance(memview, _memoryviewslice):
+ *         obj = memview             # <<<<<<<<<<<<<<
+ *         return &obj.from_slice
+ *     else:
+ */
+    if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(2, 1056, __pyx_L1_error)
+    __pyx_t_3 = ((PyObject *)__pyx_v_memview);
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "View.MemoryView":1057
+ *     if isinstance(memview, _memoryviewslice):
+ *         obj = memview
+ *         return &obj.from_slice             # <<<<<<<<<<<<<<
+ *     else:
+ *         slice_copy(memview, mslice)
+ */
+    __pyx_r = (&__pyx_v_obj->from_slice);
+    goto __pyx_L0;
+
+    /* "View.MemoryView":1055
+ *                                                    __Pyx_memviewslice *mslice) except NULL:
+ *     cdef _memoryviewslice obj
+ *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
+ *         obj = memview
+ *         return &obj.from_slice
+ */
+  }
+
+  /* "View.MemoryView":1059
+ *         return &obj.from_slice
+ *     else:
+ *         slice_copy(memview, mslice)             # <<<<<<<<<<<<<<
+ *         return mslice
+ * 
+ */
+  /*else*/ {
+    __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice);
+
+    /* "View.MemoryView":1060
+ *     else:
+ *         slice_copy(memview, mslice)
+ *         return mslice             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_slice_copy')
+ */
+    __pyx_r = __pyx_v_mslice;
+    goto __pyx_L0;
+  }
+
+  /* "View.MemoryView":1052
+ * 
+ * @cname('__pyx_memoryview_get_slice_from_memoryview')
+ * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview,             # <<<<<<<<<<<<<<
+ *                                                    __Pyx_memviewslice *mslice) except NULL:
+ *     cdef _memoryviewslice obj
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_obj);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1063
+ * 
+ * @cname('__pyx_memoryview_slice_copy')
+ * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst):             # <<<<<<<<<<<<<<
+ *     cdef int dim
+ *     cdef (Py_ssize_t*) shape, strides, suboffsets
+ */
+
+static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) {
+  int __pyx_v_dim;
+  Py_ssize_t *__pyx_v_shape;
+  Py_ssize_t *__pyx_v_strides;
+  Py_ssize_t *__pyx_v_suboffsets;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t *__pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  __Pyx_RefNannySetupContext("slice_copy", 0);
+
+  /* "View.MemoryView":1067
+ *     cdef (Py_ssize_t*) shape, strides, suboffsets
+ * 
+ *     shape = memview.view.shape             # <<<<<<<<<<<<<<
+ *     strides = memview.view.strides
+ *     suboffsets = memview.view.suboffsets
+ */
+  __pyx_t_1 = __pyx_v_memview->view.shape;
+  __pyx_v_shape = __pyx_t_1;
+
+  /* "View.MemoryView":1068
+ * 
+ *     shape = memview.view.shape
+ *     strides = memview.view.strides             # <<<<<<<<<<<<<<
+ *     suboffsets = memview.view.suboffsets
+ * 
+ */
+  __pyx_t_1 = __pyx_v_memview->view.strides;
+  __pyx_v_strides = __pyx_t_1;
+
+  /* "View.MemoryView":1069
+ *     shape = memview.view.shape
+ *     strides = memview.view.strides
+ *     suboffsets = memview.view.suboffsets             # <<<<<<<<<<<<<<
+ * 
+ *     dst.memview = <__pyx_memoryview *> memview
+ */
+  __pyx_t_1 = __pyx_v_memview->view.suboffsets;
+  __pyx_v_suboffsets = __pyx_t_1;
+
+  /* "View.MemoryView":1071
+ *     suboffsets = memview.view.suboffsets
+ * 
+ *     dst.memview = <__pyx_memoryview *> memview             # <<<<<<<<<<<<<<
+ *     dst.data =  memview.view.buf
+ * 
+ */
+  __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview);
+
+  /* "View.MemoryView":1072
+ * 
+ *     dst.memview = <__pyx_memoryview *> memview
+ *     dst.data =  memview.view.buf             # <<<<<<<<<<<<<<
+ * 
+ *     for dim in range(memview.view.ndim):
+ */
+  __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf);
+
+  /* "View.MemoryView":1074
+ *     dst.data =  memview.view.buf
+ * 
+ *     for dim in range(memview.view.ndim):             # <<<<<<<<<<<<<<
+ *         dst.shape[dim] = shape[dim]
+ *         dst.strides[dim] = strides[dim]
+ */
+  __pyx_t_2 = __pyx_v_memview->view.ndim;
+  __pyx_t_3 = __pyx_t_2;
+  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+    __pyx_v_dim = __pyx_t_4;
+
+    /* "View.MemoryView":1075
+ * 
+ *     for dim in range(memview.view.ndim):
+ *         dst.shape[dim] = shape[dim]             # <<<<<<<<<<<<<<
+ *         dst.strides[dim] = strides[dim]
+ *         dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
+ */
+    (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]);
+
+    /* "View.MemoryView":1076
+ *     for dim in range(memview.view.ndim):
+ *         dst.shape[dim] = shape[dim]
+ *         dst.strides[dim] = strides[dim]             # <<<<<<<<<<<<<<
+ *         dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
+ * 
+ */
+    (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]);
+
+    /* "View.MemoryView":1077
+ *         dst.shape[dim] = shape[dim]
+ *         dst.strides[dim] = strides[dim]
+ *         dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_copy_object')
+ */
+    if ((__pyx_v_suboffsets != 0)) {
+      __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]);
+    } else {
+      __pyx_t_5 = -1L;
+    }
+    (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5;
+  }
+
+  /* "View.MemoryView":1063
+ * 
+ * @cname('__pyx_memoryview_slice_copy')
+ * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst):             # <<<<<<<<<<<<<<
+ *     cdef int dim
+ *     cdef (Py_ssize_t*) shape, strides, suboffsets
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":1080
+ * 
+ * @cname('__pyx_memoryview_copy_object')
+ * cdef memoryview_copy(memoryview memview):             # <<<<<<<<<<<<<<
+ *     "Create a new memoryview object"
+ *     cdef __Pyx_memviewslice memviewslice
+ */
+
+static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) {
+  __Pyx_memviewslice __pyx_v_memviewslice;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("memoryview_copy", 0);
+
+  /* "View.MemoryView":1083
+ *     "Create a new memoryview object"
+ *     cdef __Pyx_memviewslice memviewslice
+ *     slice_copy(memview, &memviewslice)             # <<<<<<<<<<<<<<
+ *     return memoryview_copy_from_slice(memview, &memviewslice)
+ * 
+ */
+  __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice));
+
+  /* "View.MemoryView":1084
+ *     cdef __Pyx_memviewslice memviewslice
+ *     slice_copy(memview, &memviewslice)
+ *     return memoryview_copy_from_slice(memview, &memviewslice)             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_copy_object_from_slice')
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1084, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":1080
+ * 
+ * @cname('__pyx_memoryview_copy_object')
+ * cdef memoryview_copy(memoryview memview):             # <<<<<<<<<<<<<<
+ *     "Create a new memoryview object"
+ *     cdef __Pyx_memviewslice memviewslice
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1087
+ * 
+ * @cname('__pyx_memoryview_copy_object_from_slice')
+ * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice):             # <<<<<<<<<<<<<<
+ *     """
+ *     Create a new memoryview object from a given memoryview object and slice.
+ */
+
+static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) {
+  PyObject *(*__pyx_v_to_object_func)(char *);
+  int (*__pyx_v_to_dtype_func)(char *, PyObject *);
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *(*__pyx_t_3)(char *);
+  int (*__pyx_t_4)(char *, PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0);
+
+  /* "View.MemoryView":1094
+ *     cdef int (*to_dtype_func)(char *, object) except 0
+ * 
+ *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
+ *         to_object_func = (<_memoryviewslice> memview).to_object_func
+ *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
+ */
+  __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1095
+ * 
+ *     if isinstance(memview, _memoryviewslice):
+ *         to_object_func = (<_memoryviewslice> memview).to_object_func             # <<<<<<<<<<<<<<
+ *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
+ *     else:
+ */
+    __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func;
+    __pyx_v_to_object_func = __pyx_t_3;
+
+    /* "View.MemoryView":1096
+ *     if isinstance(memview, _memoryviewslice):
+ *         to_object_func = (<_memoryviewslice> memview).to_object_func
+ *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func             # <<<<<<<<<<<<<<
+ *     else:
+ *         to_object_func = NULL
+ */
+    __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func;
+    __pyx_v_to_dtype_func = __pyx_t_4;
+
+    /* "View.MemoryView":1094
+ *     cdef int (*to_dtype_func)(char *, object) except 0
+ * 
+ *     if isinstance(memview, _memoryviewslice):             # <<<<<<<<<<<<<<
+ *         to_object_func = (<_memoryviewslice> memview).to_object_func
+ *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":1098
+ *         to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
+ *     else:
+ *         to_object_func = NULL             # <<<<<<<<<<<<<<
+ *         to_dtype_func = NULL
+ * 
+ */
+  /*else*/ {
+    __pyx_v_to_object_func = NULL;
+
+    /* "View.MemoryView":1099
+ *     else:
+ *         to_object_func = NULL
+ *         to_dtype_func = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     return memoryview_fromslice(memviewslice[0], memview.view.ndim,
+ */
+    __pyx_v_to_dtype_func = NULL;
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":1101
+ *         to_dtype_func = NULL
+ * 
+ *     return memoryview_fromslice(memviewslice[0], memview.view.ndim,             # <<<<<<<<<<<<<<
+ *                                 to_object_func, to_dtype_func,
+ *                                 memview.dtype_is_object)
+ */
+  __Pyx_XDECREF(__pyx_r);
+
+  /* "View.MemoryView":1103
+ *     return memoryview_fromslice(memviewslice[0], memview.view.ndim,
+ *                                 to_object_func, to_dtype_func,
+ *                                 memview.dtype_is_object)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":1087
+ * 
+ * @cname('__pyx_memoryview_copy_object_from_slice')
+ * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice):             # <<<<<<<<<<<<<<
+ *     """
+ *     Create a new memoryview object from a given memoryview object and slice.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1109
+ * 
+ * 
+ * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:             # <<<<<<<<<<<<<<
+ *     if arg < 0:
+ *         return -arg
+ */
+
+static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) {
+  Py_ssize_t __pyx_r;
+  int __pyx_t_1;
+
+  /* "View.MemoryView":1110
+ * 
+ * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
+ *     if arg < 0:             # <<<<<<<<<<<<<<
+ *         return -arg
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_arg < 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":1111
+ * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
+ *     if arg < 0:
+ *         return -arg             # <<<<<<<<<<<<<<
+ *     else:
+ *         return arg
+ */
+    __pyx_r = (-__pyx_v_arg);
+    goto __pyx_L0;
+
+    /* "View.MemoryView":1110
+ * 
+ * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
+ *     if arg < 0:             # <<<<<<<<<<<<<<
+ *         return -arg
+ *     else:
+ */
+  }
+
+  /* "View.MemoryView":1113
+ *         return -arg
+ *     else:
+ *         return arg             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_get_best_slice_order')
+ */
+  /*else*/ {
+    __pyx_r = __pyx_v_arg;
+    goto __pyx_L0;
+  }
+
+  /* "View.MemoryView":1109
+ * 
+ * 
+ * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:             # <<<<<<<<<<<<<<
+ *     if arg < 0:
+ *         return -arg
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1116
+ * 
+ * @cname('__pyx_get_best_slice_order')
+ * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil:             # <<<<<<<<<<<<<<
+ *     """
+ *     Figure out the best memory access order for a given slice.
+ */
+
+static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) {
+  int __pyx_v_i;
+  Py_ssize_t __pyx_v_c_stride;
+  Py_ssize_t __pyx_v_f_stride;
+  char __pyx_r;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+
+  /* "View.MemoryView":1121
+ *     """
+ *     cdef int i
+ *     cdef Py_ssize_t c_stride = 0             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t f_stride = 0
+ * 
+ */
+  __pyx_v_c_stride = 0;
+
+  /* "View.MemoryView":1122
+ *     cdef int i
+ *     cdef Py_ssize_t c_stride = 0
+ *     cdef Py_ssize_t f_stride = 0             # <<<<<<<<<<<<<<
+ * 
+ *     for i in range(ndim - 1, -1, -1):
+ */
+  __pyx_v_f_stride = 0;
+
+  /* "View.MemoryView":1124
+ *     cdef Py_ssize_t f_stride = 0
+ * 
+ *     for i in range(ndim - 1, -1, -1):             # <<<<<<<<<<<<<<
+ *         if mslice.shape[i] > 1:
+ *             c_stride = mslice.strides[i]
+ */
+  for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) {
+    __pyx_v_i = __pyx_t_1;
+
+    /* "View.MemoryView":1125
+ * 
+ *     for i in range(ndim - 1, -1, -1):
+ *         if mslice.shape[i] > 1:             # <<<<<<<<<<<<<<
+ *             c_stride = mslice.strides[i]
+ *             break
+ */
+    __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1126
+ *     for i in range(ndim - 1, -1, -1):
+ *         if mslice.shape[i] > 1:
+ *             c_stride = mslice.strides[i]             # <<<<<<<<<<<<<<
+ *             break
+ * 
+ */
+      __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]);
+
+      /* "View.MemoryView":1127
+ *         if mslice.shape[i] > 1:
+ *             c_stride = mslice.strides[i]
+ *             break             # <<<<<<<<<<<<<<
+ * 
+ *     for i in range(ndim):
+ */
+      goto __pyx_L4_break;
+
+      /* "View.MemoryView":1125
+ * 
+ *     for i in range(ndim - 1, -1, -1):
+ *         if mslice.shape[i] > 1:             # <<<<<<<<<<<<<<
+ *             c_stride = mslice.strides[i]
+ *             break
+ */
+    }
+  }
+  __pyx_L4_break:;
+
+  /* "View.MemoryView":1129
+ *             break
+ * 
+ *     for i in range(ndim):             # <<<<<<<<<<<<<<
+ *         if mslice.shape[i] > 1:
+ *             f_stride = mslice.strides[i]
+ */
+  __pyx_t_1 = __pyx_v_ndim;
+  __pyx_t_3 = __pyx_t_1;
+  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+    __pyx_v_i = __pyx_t_4;
+
+    /* "View.MemoryView":1130
+ * 
+ *     for i in range(ndim):
+ *         if mslice.shape[i] > 1:             # <<<<<<<<<<<<<<
+ *             f_stride = mslice.strides[i]
+ *             break
+ */
+    __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1131
+ *     for i in range(ndim):
+ *         if mslice.shape[i] > 1:
+ *             f_stride = mslice.strides[i]             # <<<<<<<<<<<<<<
+ *             break
+ * 
+ */
+      __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]);
+
+      /* "View.MemoryView":1132
+ *         if mslice.shape[i] > 1:
+ *             f_stride = mslice.strides[i]
+ *             break             # <<<<<<<<<<<<<<
+ * 
+ *     if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
+ */
+      goto __pyx_L7_break;
+
+      /* "View.MemoryView":1130
+ * 
+ *     for i in range(ndim):
+ *         if mslice.shape[i] > 1:             # <<<<<<<<<<<<<<
+ *             f_stride = mslice.strides[i]
+ *             break
+ */
+    }
+  }
+  __pyx_L7_break:;
+
+  /* "View.MemoryView":1134
+ *             break
+ * 
+ *     if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):             # <<<<<<<<<<<<<<
+ *         return 'C'
+ *     else:
+ */
+  __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1135
+ * 
+ *     if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
+ *         return 'C'             # <<<<<<<<<<<<<<
+ *     else:
+ *         return 'F'
+ */
+    __pyx_r = 'C';
+    goto __pyx_L0;
+
+    /* "View.MemoryView":1134
+ *             break
+ * 
+ *     if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):             # <<<<<<<<<<<<<<
+ *         return 'C'
+ *     else:
+ */
+  }
+
+  /* "View.MemoryView":1137
+ *         return 'C'
+ *     else:
+ *         return 'F'             # <<<<<<<<<<<<<<
+ * 
+ * @cython.cdivision(True)
+ */
+  /*else*/ {
+    __pyx_r = 'F';
+    goto __pyx_L0;
+  }
+
+  /* "View.MemoryView":1116
+ * 
+ * @cname('__pyx_get_best_slice_order')
+ * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil:             # <<<<<<<<<<<<<<
+ *     """
+ *     Figure out the best memory access order for a given slice.
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1140
+ * 
+ * @cython.cdivision(True)
+ * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides,             # <<<<<<<<<<<<<<
+ *                                    char *dst_data, Py_ssize_t *dst_strides,
+ *                                    Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
+ */
+
+static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) {
+  CYTHON_UNUSED Py_ssize_t __pyx_v_i;
+  CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent;
+  Py_ssize_t __pyx_v_dst_extent;
+  Py_ssize_t __pyx_v_src_stride;
+  Py_ssize_t __pyx_v_dst_stride;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+
+  /* "View.MemoryView":1147
+ * 
+ *     cdef Py_ssize_t i
+ *     cdef Py_ssize_t src_extent = src_shape[0]             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t dst_extent = dst_shape[0]
+ *     cdef Py_ssize_t src_stride = src_strides[0]
+ */
+  __pyx_v_src_extent = (__pyx_v_src_shape[0]);
+
+  /* "View.MemoryView":1148
+ *     cdef Py_ssize_t i
+ *     cdef Py_ssize_t src_extent = src_shape[0]
+ *     cdef Py_ssize_t dst_extent = dst_shape[0]             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t src_stride = src_strides[0]
+ *     cdef Py_ssize_t dst_stride = dst_strides[0]
+ */
+  __pyx_v_dst_extent = (__pyx_v_dst_shape[0]);
+
+  /* "View.MemoryView":1149
+ *     cdef Py_ssize_t src_extent = src_shape[0]
+ *     cdef Py_ssize_t dst_extent = dst_shape[0]
+ *     cdef Py_ssize_t src_stride = src_strides[0]             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t dst_stride = dst_strides[0]
+ * 
+ */
+  __pyx_v_src_stride = (__pyx_v_src_strides[0]);
+
+  /* "View.MemoryView":1150
+ *     cdef Py_ssize_t dst_extent = dst_shape[0]
+ *     cdef Py_ssize_t src_stride = src_strides[0]
+ *     cdef Py_ssize_t dst_stride = dst_strides[0]             # <<<<<<<<<<<<<<
+ * 
+ *     if ndim == 1:
+ */
+  __pyx_v_dst_stride = (__pyx_v_dst_strides[0]);
+
+  /* "View.MemoryView":1152
+ *     cdef Py_ssize_t dst_stride = dst_strides[0]
+ * 
+ *     if ndim == 1:             # <<<<<<<<<<<<<<
+ *        if (src_stride > 0 and dst_stride > 0 and
+ *             src_stride == itemsize ==  dst_stride):
+ */
+  __pyx_t_1 = ((__pyx_v_ndim == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":1153
+ * 
+ *     if ndim == 1:
+ *        if (src_stride > 0 and dst_stride > 0 and             # <<<<<<<<<<<<<<
+ *             src_stride == itemsize ==  dst_stride):
+ *            memcpy(dst_data, src_data, itemsize * dst_extent)
+ */
+    __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L5_bool_binop_done;
+    }
+    __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L5_bool_binop_done;
+    }
+
+    /* "View.MemoryView":1154
+ *     if ndim == 1:
+ *        if (src_stride > 0 and dst_stride > 0 and
+ *             src_stride == itemsize ==  dst_stride):             # <<<<<<<<<<<<<<
+ *            memcpy(dst_data, src_data, itemsize * dst_extent)
+ *        else:
+ */
+    __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize);
+    if (__pyx_t_2) {
+      __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride));
+    }
+    __pyx_t_3 = (__pyx_t_2 != 0);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_L5_bool_binop_done:;
+
+    /* "View.MemoryView":1153
+ * 
+ *     if ndim == 1:
+ *        if (src_stride > 0 and dst_stride > 0 and             # <<<<<<<<<<<<<<
+ *             src_stride == itemsize ==  dst_stride):
+ *            memcpy(dst_data, src_data, itemsize * dst_extent)
+ */
+    if (__pyx_t_1) {
+
+      /* "View.MemoryView":1155
+ *        if (src_stride > 0 and dst_stride > 0 and
+ *             src_stride == itemsize ==  dst_stride):
+ *            memcpy(dst_data, src_data, itemsize * dst_extent)             # <<<<<<<<<<<<<<
+ *        else:
+ *            for i in range(dst_extent):
+ */
+      (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent)));
+
+      /* "View.MemoryView":1153
+ * 
+ *     if ndim == 1:
+ *        if (src_stride > 0 and dst_stride > 0 and             # <<<<<<<<<<<<<<
+ *             src_stride == itemsize ==  dst_stride):
+ *            memcpy(dst_data, src_data, itemsize * dst_extent)
+ */
+      goto __pyx_L4;
+    }
+
+    /* "View.MemoryView":1157
+ *            memcpy(dst_data, src_data, itemsize * dst_extent)
+ *        else:
+ *            for i in range(dst_extent):             # <<<<<<<<<<<<<<
+ *                memcpy(dst_data, src_data, itemsize)
+ *                src_data += src_stride
+ */
+    /*else*/ {
+      __pyx_t_4 = __pyx_v_dst_extent;
+      __pyx_t_5 = __pyx_t_4;
+      for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+        __pyx_v_i = __pyx_t_6;
+
+        /* "View.MemoryView":1158
+ *        else:
+ *            for i in range(dst_extent):
+ *                memcpy(dst_data, src_data, itemsize)             # <<<<<<<<<<<<<<
+ *                src_data += src_stride
+ *                dst_data += dst_stride
+ */
+        (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize));
+
+        /* "View.MemoryView":1159
+ *            for i in range(dst_extent):
+ *                memcpy(dst_data, src_data, itemsize)
+ *                src_data += src_stride             # <<<<<<<<<<<<<<
+ *                dst_data += dst_stride
+ *     else:
+ */
+        __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride);
+
+        /* "View.MemoryView":1160
+ *                memcpy(dst_data, src_data, itemsize)
+ *                src_data += src_stride
+ *                dst_data += dst_stride             # <<<<<<<<<<<<<<
+ *     else:
+ *         for i in range(dst_extent):
+ */
+        __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride);
+      }
+    }
+    __pyx_L4:;
+
+    /* "View.MemoryView":1152
+ *     cdef Py_ssize_t dst_stride = dst_strides[0]
+ * 
+ *     if ndim == 1:             # <<<<<<<<<<<<<<
+ *        if (src_stride > 0 and dst_stride > 0 and
+ *             src_stride == itemsize ==  dst_stride):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":1162
+ *                dst_data += dst_stride
+ *     else:
+ *         for i in range(dst_extent):             # <<<<<<<<<<<<<<
+ *             _copy_strided_to_strided(src_data, src_strides + 1,
+ *                                      dst_data, dst_strides + 1,
+ */
+  /*else*/ {
+    __pyx_t_4 = __pyx_v_dst_extent;
+    __pyx_t_5 = __pyx_t_4;
+    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+      __pyx_v_i = __pyx_t_6;
+
+      /* "View.MemoryView":1163
+ *     else:
+ *         for i in range(dst_extent):
+ *             _copy_strided_to_strided(src_data, src_strides + 1,             # <<<<<<<<<<<<<<
+ *                                      dst_data, dst_strides + 1,
+ *                                      src_shape + 1, dst_shape + 1,
+ */
+      _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize);
+
+      /* "View.MemoryView":1167
+ *                                      src_shape + 1, dst_shape + 1,
+ *                                      ndim - 1, itemsize)
+ *             src_data += src_stride             # <<<<<<<<<<<<<<
+ *             dst_data += dst_stride
+ * 
+ */
+      __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride);
+
+      /* "View.MemoryView":1168
+ *                                      ndim - 1, itemsize)
+ *             src_data += src_stride
+ *             dst_data += dst_stride             # <<<<<<<<<<<<<<
+ * 
+ * cdef void copy_strided_to_strided(__Pyx_memviewslice *src,
+ */
+      __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride);
+    }
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":1140
+ * 
+ * @cython.cdivision(True)
+ * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides,             # <<<<<<<<<<<<<<
+ *                                    char *dst_data, Py_ssize_t *dst_strides,
+ *                                    Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
+ */
+
+  /* function exit code */
+}
+
+/* "View.MemoryView":1170
+ *             dst_data += dst_stride
+ * 
+ * cdef void copy_strided_to_strided(__Pyx_memviewslice *src,             # <<<<<<<<<<<<<<
+ *                                   __Pyx_memviewslice *dst,
+ *                                   int ndim, size_t itemsize) nogil:
+ */
+
+static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) {
+
+  /* "View.MemoryView":1173
+ *                                   __Pyx_memviewslice *dst,
+ *                                   int ndim, size_t itemsize) nogil:
+ *     _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides,             # <<<<<<<<<<<<<<
+ *                              src.shape, dst.shape, ndim, itemsize)
+ * 
+ */
+  _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize);
+
+  /* "View.MemoryView":1170
+ *             dst_data += dst_stride
+ * 
+ * cdef void copy_strided_to_strided(__Pyx_memviewslice *src,             # <<<<<<<<<<<<<<
+ *                                   __Pyx_memviewslice *dst,
+ *                                   int ndim, size_t itemsize) nogil:
+ */
+
+  /* function exit code */
+}
+
+/* "View.MemoryView":1177
+ * 
+ * @cname('__pyx_memoryview_slice_get_size')
+ * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil:             # <<<<<<<<<<<<<<
+ *     "Return the size of the memory occupied by the slice in number of bytes"
+ *     cdef Py_ssize_t shape, size = src.memview.view.itemsize
+ */
+
+static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) {
+  Py_ssize_t __pyx_v_shape;
+  Py_ssize_t __pyx_v_size;
+  Py_ssize_t __pyx_r;
+  Py_ssize_t __pyx_t_1;
+  Py_ssize_t *__pyx_t_2;
+  Py_ssize_t *__pyx_t_3;
+  Py_ssize_t *__pyx_t_4;
+
+  /* "View.MemoryView":1179
+ * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil:
+ *     "Return the size of the memory occupied by the slice in number of bytes"
+ *     cdef Py_ssize_t shape, size = src.memview.view.itemsize             # <<<<<<<<<<<<<<
+ * 
+ *     for shape in src.shape[:ndim]:
+ */
+  __pyx_t_1 = __pyx_v_src->memview->view.itemsize;
+  __pyx_v_size = __pyx_t_1;
+
+  /* "View.MemoryView":1181
+ *     cdef Py_ssize_t shape, size = src.memview.view.itemsize
+ * 
+ *     for shape in src.shape[:ndim]:             # <<<<<<<<<<<<<<
+ *         size *= shape
+ * 
+ */
+  __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim);
+  for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) {
+    __pyx_t_2 = __pyx_t_4;
+    __pyx_v_shape = (__pyx_t_2[0]);
+
+    /* "View.MemoryView":1182
+ * 
+ *     for shape in src.shape[:ndim]:
+ *         size *= shape             # <<<<<<<<<<<<<<
+ * 
+ *     return size
+ */
+    __pyx_v_size = (__pyx_v_size * __pyx_v_shape);
+  }
+
+  /* "View.MemoryView":1184
+ *         size *= shape
+ * 
+ *     return size             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_fill_contig_strides_array')
+ */
+  __pyx_r = __pyx_v_size;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":1177
+ * 
+ * @cname('__pyx_memoryview_slice_get_size')
+ * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil:             # <<<<<<<<<<<<<<
+ *     "Return the size of the memory occupied by the slice in number of bytes"
+ *     cdef Py_ssize_t shape, size = src.memview.view.itemsize
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1187
+ * 
+ * @cname('__pyx_fill_contig_strides_array')
+ * cdef Py_ssize_t fill_contig_strides_array(             # <<<<<<<<<<<<<<
+ *                 Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
+ *                 int ndim, char order) nogil:
+ */
+
+static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) {
+  int __pyx_v_idx;
+  Py_ssize_t __pyx_r;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+
+  /* "View.MemoryView":1196
+ *     cdef int idx
+ * 
+ *     if order == 'F':             # <<<<<<<<<<<<<<
+ *         for idx in range(ndim):
+ *             strides[idx] = stride
+ */
+  __pyx_t_1 = ((__pyx_v_order == 'F') != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":1197
+ * 
+ *     if order == 'F':
+ *         for idx in range(ndim):             # <<<<<<<<<<<<<<
+ *             strides[idx] = stride
+ *             stride *= shape[idx]
+ */
+    __pyx_t_2 = __pyx_v_ndim;
+    __pyx_t_3 = __pyx_t_2;
+    for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+      __pyx_v_idx = __pyx_t_4;
+
+      /* "View.MemoryView":1198
+ *     if order == 'F':
+ *         for idx in range(ndim):
+ *             strides[idx] = stride             # <<<<<<<<<<<<<<
+ *             stride *= shape[idx]
+ *     else:
+ */
+      (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride;
+
+      /* "View.MemoryView":1199
+ *         for idx in range(ndim):
+ *             strides[idx] = stride
+ *             stride *= shape[idx]             # <<<<<<<<<<<<<<
+ *     else:
+ *         for idx in range(ndim - 1, -1, -1):
+ */
+      __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx]));
+    }
+
+    /* "View.MemoryView":1196
+ *     cdef int idx
+ * 
+ *     if order == 'F':             # <<<<<<<<<<<<<<
+ *         for idx in range(ndim):
+ *             strides[idx] = stride
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":1201
+ *             stride *= shape[idx]
+ *     else:
+ *         for idx in range(ndim - 1, -1, -1):             # <<<<<<<<<<<<<<
+ *             strides[idx] = stride
+ *             stride *= shape[idx]
+ */
+  /*else*/ {
+    for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) {
+      __pyx_v_idx = __pyx_t_2;
+
+      /* "View.MemoryView":1202
+ *     else:
+ *         for idx in range(ndim - 1, -1, -1):
+ *             strides[idx] = stride             # <<<<<<<<<<<<<<
+ *             stride *= shape[idx]
+ * 
+ */
+      (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride;
+
+      /* "View.MemoryView":1203
+ *         for idx in range(ndim - 1, -1, -1):
+ *             strides[idx] = stride
+ *             stride *= shape[idx]             # <<<<<<<<<<<<<<
+ * 
+ *     return stride
+ */
+      __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx]));
+    }
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":1205
+ *             stride *= shape[idx]
+ * 
+ *     return stride             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_copy_data_to_temp')
+ */
+  __pyx_r = __pyx_v_stride;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":1187
+ * 
+ * @cname('__pyx_fill_contig_strides_array')
+ * cdef Py_ssize_t fill_contig_strides_array(             # <<<<<<<<<<<<<<
+ *                 Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
+ *                 int ndim, char order) nogil:
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1208
+ * 
+ * @cname('__pyx_memoryview_copy_data_to_temp')
+ * cdef void *copy_data_to_temp(__Pyx_memviewslice *src,             # <<<<<<<<<<<<<<
+ *                              __Pyx_memviewslice *tmpslice,
+ *                              char order,
+ */
+
+static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) {
+  int __pyx_v_i;
+  void *__pyx_v_result;
+  size_t __pyx_v_itemsize;
+  size_t __pyx_v_size;
+  void *__pyx_r;
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  struct __pyx_memoryview_obj *__pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* "View.MemoryView":1219
+ *     cdef void *result
+ * 
+ *     cdef size_t itemsize = src.memview.view.itemsize             # <<<<<<<<<<<<<<
+ *     cdef size_t size = slice_get_size(src, ndim)
+ * 
+ */
+  __pyx_t_1 = __pyx_v_src->memview->view.itemsize;
+  __pyx_v_itemsize = __pyx_t_1;
+
+  /* "View.MemoryView":1220
+ * 
+ *     cdef size_t itemsize = src.memview.view.itemsize
+ *     cdef size_t size = slice_get_size(src, ndim)             # <<<<<<<<<<<<<<
+ * 
+ *     result = malloc(size)
+ */
+  __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim);
+
+  /* "View.MemoryView":1222
+ *     cdef size_t size = slice_get_size(src, ndim)
+ * 
+ *     result = malloc(size)             # <<<<<<<<<<<<<<
+ *     if not result:
+ *         _err(MemoryError, NULL)
+ */
+  __pyx_v_result = malloc(__pyx_v_size);
+
+  /* "View.MemoryView":1223
+ * 
+ *     result = malloc(size)
+ *     if not result:             # <<<<<<<<<<<<<<
+ *         _err(MemoryError, NULL)
+ * 
+ */
+  __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1224
+ *     result = malloc(size)
+ *     if not result:
+ *         _err(MemoryError, NULL)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 1224, __pyx_L1_error)
+
+    /* "View.MemoryView":1223
+ * 
+ *     result = malloc(size)
+ *     if not result:             # <<<<<<<<<<<<<<
+ *         _err(MemoryError, NULL)
+ * 
+ */
+  }
+
+  /* "View.MemoryView":1227
+ * 
+ * 
+ *     tmpslice.data =  result             # <<<<<<<<<<<<<<
+ *     tmpslice.memview = src.memview
+ *     for i in range(ndim):
+ */
+  __pyx_v_tmpslice->data = ((char *)__pyx_v_result);
+
+  /* "View.MemoryView":1228
+ * 
+ *     tmpslice.data =  result
+ *     tmpslice.memview = src.memview             # <<<<<<<<<<<<<<
+ *     for i in range(ndim):
+ *         tmpslice.shape[i] = src.shape[i]
+ */
+  __pyx_t_4 = __pyx_v_src->memview;
+  __pyx_v_tmpslice->memview = __pyx_t_4;
+
+  /* "View.MemoryView":1229
+ *     tmpslice.data =  result
+ *     tmpslice.memview = src.memview
+ *     for i in range(ndim):             # <<<<<<<<<<<<<<
+ *         tmpslice.shape[i] = src.shape[i]
+ *         tmpslice.suboffsets[i] = -1
+ */
+  __pyx_t_3 = __pyx_v_ndim;
+  __pyx_t_5 = __pyx_t_3;
+  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+    __pyx_v_i = __pyx_t_6;
+
+    /* "View.MemoryView":1230
+ *     tmpslice.memview = src.memview
+ *     for i in range(ndim):
+ *         tmpslice.shape[i] = src.shape[i]             # <<<<<<<<<<<<<<
+ *         tmpslice.suboffsets[i] = -1
+ * 
+ */
+    (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]);
+
+    /* "View.MemoryView":1231
+ *     for i in range(ndim):
+ *         tmpslice.shape[i] = src.shape[i]
+ *         tmpslice.suboffsets[i] = -1             # <<<<<<<<<<<<<<
+ * 
+ *     fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize,
+ */
+    (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L;
+  }
+
+  /* "View.MemoryView":1233
+ *         tmpslice.suboffsets[i] = -1
+ * 
+ *     fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize,             # <<<<<<<<<<<<<<
+ *                               ndim, order)
+ * 
+ */
+  (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order));
+
+  /* "View.MemoryView":1237
+ * 
+ * 
+ *     for i in range(ndim):             # <<<<<<<<<<<<<<
+ *         if tmpslice.shape[i] == 1:
+ *             tmpslice.strides[i] = 0
+ */
+  __pyx_t_3 = __pyx_v_ndim;
+  __pyx_t_5 = __pyx_t_3;
+  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+    __pyx_v_i = __pyx_t_6;
+
+    /* "View.MemoryView":1238
+ * 
+ *     for i in range(ndim):
+ *         if tmpslice.shape[i] == 1:             # <<<<<<<<<<<<<<
+ *             tmpslice.strides[i] = 0
+ * 
+ */
+    __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1239
+ *     for i in range(ndim):
+ *         if tmpslice.shape[i] == 1:
+ *             tmpslice.strides[i] = 0             # <<<<<<<<<<<<<<
+ * 
+ *     if slice_is_contig(src[0], order, ndim):
+ */
+      (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0;
+
+      /* "View.MemoryView":1238
+ * 
+ *     for i in range(ndim):
+ *         if tmpslice.shape[i] == 1:             # <<<<<<<<<<<<<<
+ *             tmpslice.strides[i] = 0
+ * 
+ */
+    }
+  }
+
+  /* "View.MemoryView":1241
+ *             tmpslice.strides[i] = 0
+ * 
+ *     if slice_is_contig(src[0], order, ndim):             # <<<<<<<<<<<<<<
+ *         memcpy(result, src.data, size)
+ *     else:
+ */
+  __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1242
+ * 
+ *     if slice_is_contig(src[0], order, ndim):
+ *         memcpy(result, src.data, size)             # <<<<<<<<<<<<<<
+ *     else:
+ *         copy_strided_to_strided(src, tmpslice, ndim, itemsize)
+ */
+    (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size));
+
+    /* "View.MemoryView":1241
+ *             tmpslice.strides[i] = 0
+ * 
+ *     if slice_is_contig(src[0], order, ndim):             # <<<<<<<<<<<<<<
+ *         memcpy(result, src.data, size)
+ *     else:
+ */
+    goto __pyx_L9;
+  }
+
+  /* "View.MemoryView":1244
+ *         memcpy(result, src.data, size)
+ *     else:
+ *         copy_strided_to_strided(src, tmpslice, ndim, itemsize)             # <<<<<<<<<<<<<<
+ * 
+ *     return result
+ */
+  /*else*/ {
+    copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize);
+  }
+  __pyx_L9:;
+
+  /* "View.MemoryView":1246
+ *         copy_strided_to_strided(src, tmpslice, ndim, itemsize)
+ * 
+ *     return result             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":1208
+ * 
+ * @cname('__pyx_memoryview_copy_data_to_temp')
+ * cdef void *copy_data_to_temp(__Pyx_memviewslice *src,             # <<<<<<<<<<<<<<
+ *                              __Pyx_memviewslice *tmpslice,
+ *                              char order,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  {
+    #ifdef WITH_THREAD
+    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+    #endif
+    __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    #ifdef WITH_THREAD
+    __Pyx_PyGILState_Release(__pyx_gilstate_save);
+    #endif
+  }
+  __pyx_r = NULL;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1251
+ * 
+ * @cname('__pyx_memoryview_err_extents')
+ * cdef int _err_extents(int i, Py_ssize_t extent1,             # <<<<<<<<<<<<<<
+ *                              Py_ssize_t extent2) except -1 with gil:
+ *     raise ValueError("got differing extents in dimension %d (got %d and %d)" %
+ */
+
+static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("_err_extents", 0);
+
+  /* "View.MemoryView":1254
+ *                              Py_ssize_t extent2) except -1 with gil:
+ *     raise ValueError("got differing extents in dimension %d (got %d and %d)" %
+ *                                                         (i, extent1, extent2))             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_err_dim')
+ */
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+
+  /* "View.MemoryView":1253
+ * cdef int _err_extents(int i, Py_ssize_t extent1,
+ *                              Py_ssize_t extent2) except -1 with gil:
+ *     raise ValueError("got differing extents in dimension %d (got %d and %d)" %             # <<<<<<<<<<<<<<
+ *                                                         (i, extent1, extent2))
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __PYX_ERR(2, 1253, __pyx_L1_error)
+
+  /* "View.MemoryView":1251
+ * 
+ * @cname('__pyx_memoryview_err_extents')
+ * cdef int _err_extents(int i, Py_ssize_t extent1,             # <<<<<<<<<<<<<<
+ *                              Py_ssize_t extent2) except -1 with gil:
+ *     raise ValueError("got differing extents in dimension %d (got %d and %d)" %
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1257
+ * 
+ * @cname('__pyx_memoryview_err_dim')
+ * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil:             # <<<<<<<<<<<<<<
+ *     raise error(msg.decode('ascii') % dim)
+ * 
+ */
+
+static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("_err_dim", 0);
+  __Pyx_INCREF(__pyx_v_error);
+
+  /* "View.MemoryView":1258
+ * @cname('__pyx_memoryview_err_dim')
+ * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil:
+ *     raise error(msg.decode('ascii') % dim)             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_err')
+ */
+  __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_INCREF(__pyx_v_error);
+  __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __PYX_ERR(2, 1258, __pyx_L1_error)
+
+  /* "View.MemoryView":1257
+ * 
+ * @cname('__pyx_memoryview_err_dim')
+ * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil:             # <<<<<<<<<<<<<<
+ *     raise error(msg.decode('ascii') % dim)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __Pyx_XDECREF(__pyx_v_error);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1261
+ * 
+ * @cname('__pyx_memoryview_err')
+ * cdef int _err(object error, char *msg) except -1 with gil:             # <<<<<<<<<<<<<<
+ *     if msg != NULL:
+ *         raise error(msg.decode('ascii'))
+ */
+
+static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("_err", 0);
+  __Pyx_INCREF(__pyx_v_error);
+
+  /* "View.MemoryView":1262
+ * @cname('__pyx_memoryview_err')
+ * cdef int _err(object error, char *msg) except -1 with gil:
+ *     if msg != NULL:             # <<<<<<<<<<<<<<
+ *         raise error(msg.decode('ascii'))
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_msg != NULL) != 0);
+  if (unlikely(__pyx_t_1)) {
+
+    /* "View.MemoryView":1263
+ * cdef int _err(object error, char *msg) except -1 with gil:
+ *     if msg != NULL:
+ *         raise error(msg.decode('ascii'))             # <<<<<<<<<<<<<<
+ *     else:
+ *         raise error
+ */
+    __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1263, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_v_error);
+    __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_5)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1263, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(2, 1263, __pyx_L1_error)
+
+    /* "View.MemoryView":1262
+ * @cname('__pyx_memoryview_err')
+ * cdef int _err(object error, char *msg) except -1 with gil:
+ *     if msg != NULL:             # <<<<<<<<<<<<<<
+ *         raise error(msg.decode('ascii'))
+ *     else:
+ */
+  }
+
+  /* "View.MemoryView":1265
+ *         raise error(msg.decode('ascii'))
+ *     else:
+ *         raise error             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_copy_contents')
+ */
+  /*else*/ {
+    __Pyx_Raise(__pyx_v_error, 0, 0, 0);
+    __PYX_ERR(2, 1265, __pyx_L1_error)
+  }
+
+  /* "View.MemoryView":1261
+ * 
+ * @cname('__pyx_memoryview_err')
+ * cdef int _err(object error, char *msg) except -1 with gil:             # <<<<<<<<<<<<<<
+ *     if msg != NULL:
+ *         raise error(msg.decode('ascii'))
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __Pyx_XDECREF(__pyx_v_error);
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1268
+ * 
+ * @cname('__pyx_memoryview_copy_contents')
+ * cdef int memoryview_copy_contents(__Pyx_memviewslice src,             # <<<<<<<<<<<<<<
+ *                                   __Pyx_memviewslice dst,
+ *                                   int src_ndim, int dst_ndim,
+ */
+
+static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) {
+  void *__pyx_v_tmpdata;
+  size_t __pyx_v_itemsize;
+  int __pyx_v_i;
+  char __pyx_v_order;
+  int __pyx_v_broadcasting;
+  int __pyx_v_direct_copy;
+  __Pyx_memviewslice __pyx_v_tmp;
+  int __pyx_v_ndim;
+  int __pyx_r;
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  void *__pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* "View.MemoryView":1276
+ *     Check for overlapping memory and verify the shapes.
+ *     """
+ *     cdef void *tmpdata = NULL             # <<<<<<<<<<<<<<
+ *     cdef size_t itemsize = src.memview.view.itemsize
+ *     cdef int i
+ */
+  __pyx_v_tmpdata = NULL;
+
+  /* "View.MemoryView":1277
+ *     """
+ *     cdef void *tmpdata = NULL
+ *     cdef size_t itemsize = src.memview.view.itemsize             # <<<<<<<<<<<<<<
+ *     cdef int i
+ *     cdef char order = get_best_order(&src, src_ndim)
+ */
+  __pyx_t_1 = __pyx_v_src.memview->view.itemsize;
+  __pyx_v_itemsize = __pyx_t_1;
+
+  /* "View.MemoryView":1279
+ *     cdef size_t itemsize = src.memview.view.itemsize
+ *     cdef int i
+ *     cdef char order = get_best_order(&src, src_ndim)             # <<<<<<<<<<<<<<
+ *     cdef bint broadcasting = False
+ *     cdef bint direct_copy = False
+ */
+  __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim);
+
+  /* "View.MemoryView":1280
+ *     cdef int i
+ *     cdef char order = get_best_order(&src, src_ndim)
+ *     cdef bint broadcasting = False             # <<<<<<<<<<<<<<
+ *     cdef bint direct_copy = False
+ *     cdef __Pyx_memviewslice tmp
+ */
+  __pyx_v_broadcasting = 0;
+
+  /* "View.MemoryView":1281
+ *     cdef char order = get_best_order(&src, src_ndim)
+ *     cdef bint broadcasting = False
+ *     cdef bint direct_copy = False             # <<<<<<<<<<<<<<
+ *     cdef __Pyx_memviewslice tmp
+ * 
+ */
+  __pyx_v_direct_copy = 0;
+
+  /* "View.MemoryView":1284
+ *     cdef __Pyx_memviewslice tmp
+ * 
+ *     if src_ndim < dst_ndim:             # <<<<<<<<<<<<<<
+ *         broadcast_leading(&src, src_ndim, dst_ndim)
+ *     elif dst_ndim < src_ndim:
+ */
+  __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1285
+ * 
+ *     if src_ndim < dst_ndim:
+ *         broadcast_leading(&src, src_ndim, dst_ndim)             # <<<<<<<<<<<<<<
+ *     elif dst_ndim < src_ndim:
+ *         broadcast_leading(&dst, dst_ndim, src_ndim)
+ */
+    __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim);
+
+    /* "View.MemoryView":1284
+ *     cdef __Pyx_memviewslice tmp
+ * 
+ *     if src_ndim < dst_ndim:             # <<<<<<<<<<<<<<
+ *         broadcast_leading(&src, src_ndim, dst_ndim)
+ *     elif dst_ndim < src_ndim:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":1286
+ *     if src_ndim < dst_ndim:
+ *         broadcast_leading(&src, src_ndim, dst_ndim)
+ *     elif dst_ndim < src_ndim:             # <<<<<<<<<<<<<<
+ *         broadcast_leading(&dst, dst_ndim, src_ndim)
+ * 
+ */
+  __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1287
+ *         broadcast_leading(&src, src_ndim, dst_ndim)
+ *     elif dst_ndim < src_ndim:
+ *         broadcast_leading(&dst, dst_ndim, src_ndim)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef int ndim = max(src_ndim, dst_ndim)
+ */
+    __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim);
+
+    /* "View.MemoryView":1286
+ *     if src_ndim < dst_ndim:
+ *         broadcast_leading(&src, src_ndim, dst_ndim)
+ *     elif dst_ndim < src_ndim:             # <<<<<<<<<<<<<<
+ *         broadcast_leading(&dst, dst_ndim, src_ndim)
+ * 
+ */
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":1289
+ *         broadcast_leading(&dst, dst_ndim, src_ndim)
+ * 
+ *     cdef int ndim = max(src_ndim, dst_ndim)             # <<<<<<<<<<<<<<
+ * 
+ *     for i in range(ndim):
+ */
+  __pyx_t_3 = __pyx_v_dst_ndim;
+  __pyx_t_4 = __pyx_v_src_ndim;
+  if (((__pyx_t_3 > __pyx_t_4) != 0)) {
+    __pyx_t_5 = __pyx_t_3;
+  } else {
+    __pyx_t_5 = __pyx_t_4;
+  }
+  __pyx_v_ndim = __pyx_t_5;
+
+  /* "View.MemoryView":1291
+ *     cdef int ndim = max(src_ndim, dst_ndim)
+ * 
+ *     for i in range(ndim):             # <<<<<<<<<<<<<<
+ *         if src.shape[i] != dst.shape[i]:
+ *             if src.shape[i] == 1:
+ */
+  __pyx_t_5 = __pyx_v_ndim;
+  __pyx_t_3 = __pyx_t_5;
+  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+    __pyx_v_i = __pyx_t_4;
+
+    /* "View.MemoryView":1292
+ * 
+ *     for i in range(ndim):
+ *         if src.shape[i] != dst.shape[i]:             # <<<<<<<<<<<<<<
+ *             if src.shape[i] == 1:
+ *                 broadcasting = True
+ */
+    __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1293
+ *     for i in range(ndim):
+ *         if src.shape[i] != dst.shape[i]:
+ *             if src.shape[i] == 1:             # <<<<<<<<<<<<<<
+ *                 broadcasting = True
+ *                 src.strides[i] = 0
+ */
+      __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0);
+      if (__pyx_t_2) {
+
+        /* "View.MemoryView":1294
+ *         if src.shape[i] != dst.shape[i]:
+ *             if src.shape[i] == 1:
+ *                 broadcasting = True             # <<<<<<<<<<<<<<
+ *                 src.strides[i] = 0
+ *             else:
+ */
+        __pyx_v_broadcasting = 1;
+
+        /* "View.MemoryView":1295
+ *             if src.shape[i] == 1:
+ *                 broadcasting = True
+ *                 src.strides[i] = 0             # <<<<<<<<<<<<<<
+ *             else:
+ *                 _err_extents(i, dst.shape[i], src.shape[i])
+ */
+        (__pyx_v_src.strides[__pyx_v_i]) = 0;
+
+        /* "View.MemoryView":1293
+ *     for i in range(ndim):
+ *         if src.shape[i] != dst.shape[i]:
+ *             if src.shape[i] == 1:             # <<<<<<<<<<<<<<
+ *                 broadcasting = True
+ *                 src.strides[i] = 0
+ */
+        goto __pyx_L7;
+      }
+
+      /* "View.MemoryView":1297
+ *                 src.strides[i] = 0
+ *             else:
+ *                 _err_extents(i, dst.shape[i], src.shape[i])             # <<<<<<<<<<<<<<
+ * 
+ *         if src.suboffsets[i] >= 0:
+ */
+      /*else*/ {
+        __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1297, __pyx_L1_error)
+      }
+      __pyx_L7:;
+
+      /* "View.MemoryView":1292
+ * 
+ *     for i in range(ndim):
+ *         if src.shape[i] != dst.shape[i]:             # <<<<<<<<<<<<<<
+ *             if src.shape[i] == 1:
+ *                 broadcasting = True
+ */
+    }
+
+    /* "View.MemoryView":1299
+ *                 _err_extents(i, dst.shape[i], src.shape[i])
+ * 
+ *         if src.suboffsets[i] >= 0:             # <<<<<<<<<<<<<<
+ *             _err_dim(ValueError, "Dimension %d is not direct", i)
+ * 
+ */
+    __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1300
+ * 
+ *         if src.suboffsets[i] >= 0:
+ *             _err_dim(ValueError, "Dimension %d is not direct", i)             # <<<<<<<<<<<<<<
+ * 
+ *     if slices_overlap(&src, &dst, ndim, itemsize):
+ */
+      __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1300, __pyx_L1_error)
+
+      /* "View.MemoryView":1299
+ *                 _err_extents(i, dst.shape[i], src.shape[i])
+ * 
+ *         if src.suboffsets[i] >= 0:             # <<<<<<<<<<<<<<
+ *             _err_dim(ValueError, "Dimension %d is not direct", i)
+ * 
+ */
+    }
+  }
+
+  /* "View.MemoryView":1302
+ *             _err_dim(ValueError, "Dimension %d is not direct", i)
+ * 
+ *     if slices_overlap(&src, &dst, ndim, itemsize):             # <<<<<<<<<<<<<<
+ * 
+ *         if not slice_is_contig(src, order, ndim):
+ */
+  __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1304
+ *     if slices_overlap(&src, &dst, ndim, itemsize):
+ * 
+ *         if not slice_is_contig(src, order, ndim):             # <<<<<<<<<<<<<<
+ *             order = get_best_order(&dst, ndim)
+ * 
+ */
+    __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1305
+ * 
+ *         if not slice_is_contig(src, order, ndim):
+ *             order = get_best_order(&dst, ndim)             # <<<<<<<<<<<<<<
+ * 
+ *         tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)
+ */
+      __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim);
+
+      /* "View.MemoryView":1304
+ *     if slices_overlap(&src, &dst, ndim, itemsize):
+ * 
+ *         if not slice_is_contig(src, order, ndim):             # <<<<<<<<<<<<<<
+ *             order = get_best_order(&dst, ndim)
+ * 
+ */
+    }
+
+    /* "View.MemoryView":1307
+ *             order = get_best_order(&dst, ndim)
+ * 
+ *         tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)             # <<<<<<<<<<<<<<
+ *         src = tmp
+ * 
+ */
+    __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(2, 1307, __pyx_L1_error)
+    __pyx_v_tmpdata = __pyx_t_7;
+
+    /* "View.MemoryView":1308
+ * 
+ *         tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)
+ *         src = tmp             # <<<<<<<<<<<<<<
+ * 
+ *     if not broadcasting:
+ */
+    __pyx_v_src = __pyx_v_tmp;
+
+    /* "View.MemoryView":1302
+ *             _err_dim(ValueError, "Dimension %d is not direct", i)
+ * 
+ *     if slices_overlap(&src, &dst, ndim, itemsize):             # <<<<<<<<<<<<<<
+ * 
+ *         if not slice_is_contig(src, order, ndim):
+ */
+  }
+
+  /* "View.MemoryView":1310
+ *         src = tmp
+ * 
+ *     if not broadcasting:             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0);
+  if (__pyx_t_2) {
+
+    /* "View.MemoryView":1313
+ * 
+ * 
+ *         if slice_is_contig(src, 'C', ndim):             # <<<<<<<<<<<<<<
+ *             direct_copy = slice_is_contig(dst, 'C', ndim)
+ *         elif slice_is_contig(src, 'F', ndim):
+ */
+    __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1314
+ * 
+ *         if slice_is_contig(src, 'C', ndim):
+ *             direct_copy = slice_is_contig(dst, 'C', ndim)             # <<<<<<<<<<<<<<
+ *         elif slice_is_contig(src, 'F', ndim):
+ *             direct_copy = slice_is_contig(dst, 'F', ndim)
+ */
+      __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim);
+
+      /* "View.MemoryView":1313
+ * 
+ * 
+ *         if slice_is_contig(src, 'C', ndim):             # <<<<<<<<<<<<<<
+ *             direct_copy = slice_is_contig(dst, 'C', ndim)
+ *         elif slice_is_contig(src, 'F', ndim):
+ */
+      goto __pyx_L12;
+    }
+
+    /* "View.MemoryView":1315
+ *         if slice_is_contig(src, 'C', ndim):
+ *             direct_copy = slice_is_contig(dst, 'C', ndim)
+ *         elif slice_is_contig(src, 'F', ndim):             # <<<<<<<<<<<<<<
+ *             direct_copy = slice_is_contig(dst, 'F', ndim)
+ * 
+ */
+    __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1316
+ *             direct_copy = slice_is_contig(dst, 'C', ndim)
+ *         elif slice_is_contig(src, 'F', ndim):
+ *             direct_copy = slice_is_contig(dst, 'F', ndim)             # <<<<<<<<<<<<<<
+ * 
+ *         if direct_copy:
+ */
+      __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim);
+
+      /* "View.MemoryView":1315
+ *         if slice_is_contig(src, 'C', ndim):
+ *             direct_copy = slice_is_contig(dst, 'C', ndim)
+ *         elif slice_is_contig(src, 'F', ndim):             # <<<<<<<<<<<<<<
+ *             direct_copy = slice_is_contig(dst, 'F', ndim)
+ * 
+ */
+    }
+    __pyx_L12:;
+
+    /* "View.MemoryView":1318
+ *             direct_copy = slice_is_contig(dst, 'F', ndim)
+ * 
+ *         if direct_copy:             # <<<<<<<<<<<<<<
+ * 
+ *             refcount_copying(&dst, dtype_is_object, ndim, False)
+ */
+    __pyx_t_2 = (__pyx_v_direct_copy != 0);
+    if (__pyx_t_2) {
+
+      /* "View.MemoryView":1320
+ *         if direct_copy:
+ * 
+ *             refcount_copying(&dst, dtype_is_object, ndim, False)             # <<<<<<<<<<<<<<
+ *             memcpy(dst.data, src.data, slice_get_size(&src, ndim))
+ *             refcount_copying(&dst, dtype_is_object, ndim, True)
+ */
+      __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
+
+      /* "View.MemoryView":1321
+ * 
+ *             refcount_copying(&dst, dtype_is_object, ndim, False)
+ *             memcpy(dst.data, src.data, slice_get_size(&src, ndim))             # <<<<<<<<<<<<<<
+ *             refcount_copying(&dst, dtype_is_object, ndim, True)
+ *             free(tmpdata)
+ */
+      (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim)));
+
+      /* "View.MemoryView":1322
+ *             refcount_copying(&dst, dtype_is_object, ndim, False)
+ *             memcpy(dst.data, src.data, slice_get_size(&src, ndim))
+ *             refcount_copying(&dst, dtype_is_object, ndim, True)             # <<<<<<<<<<<<<<
+ *             free(tmpdata)
+ *             return 0
+ */
+      __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
+
+      /* "View.MemoryView":1323
+ *             memcpy(dst.data, src.data, slice_get_size(&src, ndim))
+ *             refcount_copying(&dst, dtype_is_object, ndim, True)
+ *             free(tmpdata)             # <<<<<<<<<<<<<<
+ *             return 0
+ * 
+ */
+      free(__pyx_v_tmpdata);
+
+      /* "View.MemoryView":1324
+ *             refcount_copying(&dst, dtype_is_object, ndim, True)
+ *             free(tmpdata)
+ *             return 0             # <<<<<<<<<<<<<<
+ * 
+ *     if order == 'F' == get_best_order(&dst, ndim):
+ */
+      __pyx_r = 0;
+      goto __pyx_L0;
+
+      /* "View.MemoryView":1318
+ *             direct_copy = slice_is_contig(dst, 'F', ndim)
+ * 
+ *         if direct_copy:             # <<<<<<<<<<<<<<
+ * 
+ *             refcount_copying(&dst, dtype_is_object, ndim, False)
+ */
+    }
+
+    /* "View.MemoryView":1310
+ *         src = tmp
+ * 
+ *     if not broadcasting:             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  }
+
+  /* "View.MemoryView":1326
+ *             return 0
+ * 
+ *     if order == 'F' == get_best_order(&dst, ndim):             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_order == 'F');
+  if (__pyx_t_2) {
+    __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim));
+  }
+  __pyx_t_8 = (__pyx_t_2 != 0);
+  if (__pyx_t_8) {
+
+    /* "View.MemoryView":1329
+ * 
+ * 
+ *         transpose_memslice(&src)             # <<<<<<<<<<<<<<
+ *         transpose_memslice(&dst)
+ * 
+ */
+    __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(2, 1329, __pyx_L1_error)
+
+    /* "View.MemoryView":1330
+ * 
+ *         transpose_memslice(&src)
+ *         transpose_memslice(&dst)             # <<<<<<<<<<<<<<
+ * 
+ *     refcount_copying(&dst, dtype_is_object, ndim, False)
+ */
+    __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(2, 1330, __pyx_L1_error)
+
+    /* "View.MemoryView":1326
+ *             return 0
+ * 
+ *     if order == 'F' == get_best_order(&dst, ndim):             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  }
+
+  /* "View.MemoryView":1332
+ *         transpose_memslice(&dst)
+ * 
+ *     refcount_copying(&dst, dtype_is_object, ndim, False)             # <<<<<<<<<<<<<<
+ *     copy_strided_to_strided(&src, &dst, ndim, itemsize)
+ *     refcount_copying(&dst, dtype_is_object, ndim, True)
+ */
+  __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
+
+  /* "View.MemoryView":1333
+ * 
+ *     refcount_copying(&dst, dtype_is_object, ndim, False)
+ *     copy_strided_to_strided(&src, &dst, ndim, itemsize)             # <<<<<<<<<<<<<<
+ *     refcount_copying(&dst, dtype_is_object, ndim, True)
+ * 
+ */
+  copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize);
+
+  /* "View.MemoryView":1334
+ *     refcount_copying(&dst, dtype_is_object, ndim, False)
+ *     copy_strided_to_strided(&src, &dst, ndim, itemsize)
+ *     refcount_copying(&dst, dtype_is_object, ndim, True)             # <<<<<<<<<<<<<<
+ * 
+ *     free(tmpdata)
+ */
+  __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
+
+  /* "View.MemoryView":1336
+ *     refcount_copying(&dst, dtype_is_object, ndim, True)
+ * 
+ *     free(tmpdata)             # <<<<<<<<<<<<<<
+ *     return 0
+ * 
+ */
+  free(__pyx_v_tmpdata);
+
+  /* "View.MemoryView":1337
+ * 
+ *     free(tmpdata)
+ *     return 0             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_broadcast_leading')
+ */
+  __pyx_r = 0;
+  goto __pyx_L0;
+
+  /* "View.MemoryView":1268
+ * 
+ * @cname('__pyx_memoryview_copy_contents')
+ * cdef int memoryview_copy_contents(__Pyx_memviewslice src,             # <<<<<<<<<<<<<<
+ *                                   __Pyx_memviewslice dst,
+ *                                   int src_ndim, int dst_ndim,
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  {
+    #ifdef WITH_THREAD
+    PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+    #endif
+    __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    #ifdef WITH_THREAD
+    __Pyx_PyGILState_Release(__pyx_gilstate_save);
+    #endif
+  }
+  __pyx_r = -1;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "View.MemoryView":1340
+ * 
+ * @cname('__pyx_memoryview_broadcast_leading')
+ * cdef void broadcast_leading(__Pyx_memviewslice *mslice,             # <<<<<<<<<<<<<<
+ *                             int ndim,
+ *                             int ndim_other) nogil:
+ */
+
+static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) {
+  int __pyx_v_i;
+  int __pyx_v_offset;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+
+  /* "View.MemoryView":1344
+ *                             int ndim_other) nogil:
+ *     cdef int i
+ *     cdef int offset = ndim_other - ndim             # <<<<<<<<<<<<<<
+ * 
+ *     for i in range(ndim - 1, -1, -1):
+ */
+  __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim);
+
+  /* "View.MemoryView":1346
+ *     cdef int offset = ndim_other - ndim
+ * 
+ *     for i in range(ndim - 1, -1, -1):             # <<<<<<<<<<<<<<
+ *         mslice.shape[i + offset] = mslice.shape[i]
+ *         mslice.strides[i + offset] = mslice.strides[i]
+ */
+  for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) {
+    __pyx_v_i = __pyx_t_1;
+
+    /* "View.MemoryView":1347
+ * 
+ *     for i in range(ndim - 1, -1, -1):
+ *         mslice.shape[i + offset] = mslice.shape[i]             # <<<<<<<<<<<<<<
+ *         mslice.strides[i + offset] = mslice.strides[i]
+ *         mslice.suboffsets[i + offset] = mslice.suboffsets[i]
+ */
+    (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]);
+
+    /* "View.MemoryView":1348
+ *     for i in range(ndim - 1, -1, -1):
+ *         mslice.shape[i + offset] = mslice.shape[i]
+ *         mslice.strides[i + offset] = mslice.strides[i]             # <<<<<<<<<<<<<<
+ *         mslice.suboffsets[i + offset] = mslice.suboffsets[i]
+ * 
+ */
+    (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]);
+
+    /* "View.MemoryView":1349
+ *         mslice.shape[i + offset] = mslice.shape[i]
+ *         mslice.strides[i + offset] = mslice.strides[i]
+ *         mslice.suboffsets[i + offset] = mslice.suboffsets[i]             # <<<<<<<<<<<<<<
+ * 
+ *     for i in range(offset):
+ */
+    (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]);
+  }
+
+  /* "View.MemoryView":1351
+ *         mslice.suboffsets[i + offset] = mslice.suboffsets[i]
+ * 
+ *     for i in range(offset):             # <<<<<<<<<<<<<<
+ *         mslice.shape[i] = 1
+ *         mslice.strides[i] = mslice.strides[0]
+ */
+  __pyx_t_1 = __pyx_v_offset;
+  __pyx_t_2 = __pyx_t_1;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+
+    /* "View.MemoryView":1352
+ * 
+ *     for i in range(offset):
+ *         mslice.shape[i] = 1             # <<<<<<<<<<<<<<
+ *         mslice.strides[i] = mslice.strides[0]
+ *         mslice.suboffsets[i] = -1
+ */
+    (__pyx_v_mslice->shape[__pyx_v_i]) = 1;
+
+    /* "View.MemoryView":1353
+ *     for i in range(offset):
+ *         mslice.shape[i] = 1
+ *         mslice.strides[i] = mslice.strides[0]             # <<<<<<<<<<<<<<
+ *         mslice.suboffsets[i] = -1
+ * 
+ */
+    (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]);
+
+    /* "View.MemoryView":1354
+ *         mslice.shape[i] = 1
+ *         mslice.strides[i] = mslice.strides[0]
+ *         mslice.suboffsets[i] = -1             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L;
+  }
+
+  /* "View.MemoryView":1340
+ * 
+ * @cname('__pyx_memoryview_broadcast_leading')
+ * cdef void broadcast_leading(__Pyx_memviewslice *mslice,             # <<<<<<<<<<<<<<
+ *                             int ndim,
+ *                             int ndim_other) nogil:
+ */
+
+  /* function exit code */
+}
+
+/* "View.MemoryView":1362
+ * 
+ * @cname('__pyx_memoryview_refcount_copying')
+ * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object,             # <<<<<<<<<<<<<<
+ *                            int ndim, bint inc) nogil:
+ * 
+ */
+
+static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) {
+  int __pyx_t_1;
+
+  /* "View.MemoryView":1366
+ * 
+ * 
+ *     if dtype_is_object:             # <<<<<<<<<<<<<<
+ *         refcount_objects_in_slice_with_gil(dst.data, dst.shape,
+ *                                            dst.strides, ndim, inc)
+ */
+  __pyx_t_1 = (__pyx_v_dtype_is_object != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":1367
+ * 
+ *     if dtype_is_object:
+ *         refcount_objects_in_slice_with_gil(dst.data, dst.shape,             # <<<<<<<<<<<<<<
+ *                                            dst.strides, ndim, inc)
+ * 
+ */
+    __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc);
+
+    /* "View.MemoryView":1366
+ * 
+ * 
+ *     if dtype_is_object:             # <<<<<<<<<<<<<<
+ *         refcount_objects_in_slice_with_gil(dst.data, dst.shape,
+ *                                            dst.strides, ndim, inc)
+ */
+  }
+
+  /* "View.MemoryView":1362
+ * 
+ * @cname('__pyx_memoryview_refcount_copying')
+ * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object,             # <<<<<<<<<<<<<<
+ *                            int ndim, bint inc) nogil:
+ * 
+ */
+
+  /* function exit code */
+}
+
+/* "View.MemoryView":1371
+ * 
+ * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil')
+ * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
+ *                                              Py_ssize_t *strides, int ndim,
+ *                                              bint inc) with gil:
+ */
+
+static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) {
+  __Pyx_RefNannyDeclarations
+  #ifdef WITH_THREAD
+  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
+  __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0);
+
+  /* "View.MemoryView":1374
+ *                                              Py_ssize_t *strides, int ndim,
+ *                                              bint inc) with gil:
+ *     refcount_objects_in_slice(data, shape, strides, ndim, inc)             # <<<<<<<<<<<<<<
+ * 
+ * @cname('__pyx_memoryview_refcount_objects_in_slice')
+ */
+  __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc);
+
+  /* "View.MemoryView":1371
+ * 
+ * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil')
+ * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
+ *                                              Py_ssize_t *strides, int ndim,
+ *                                              bint inc) with gil:
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  #ifdef WITH_THREAD
+  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+  #endif
+}
+
+/* "View.MemoryView":1377
+ * 
+ * @cname('__pyx_memoryview_refcount_objects_in_slice')
+ * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
+ *                                     Py_ssize_t *strides, int ndim, bint inc):
+ *     cdef Py_ssize_t i
+ */
+
+static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) {
+  CYTHON_UNUSED Py_ssize_t __pyx_v_i;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  Py_ssize_t __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  int __pyx_t_4;
+  __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0);
+
+  /* "View.MemoryView":1381
+ *     cdef Py_ssize_t i
+ * 
+ *     for i in range(shape[0]):             # <<<<<<<<<<<<<<
+ *         if ndim == 1:
+ *             if inc:
+ */
+  __pyx_t_1 = (__pyx_v_shape[0]);
+  __pyx_t_2 = __pyx_t_1;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+
+    /* "View.MemoryView":1382
+ * 
+ *     for i in range(shape[0]):
+ *         if ndim == 1:             # <<<<<<<<<<<<<<
+ *             if inc:
+ *                 Py_INCREF(( data)[0])
+ */
+    __pyx_t_4 = ((__pyx_v_ndim == 1) != 0);
+    if (__pyx_t_4) {
+
+      /* "View.MemoryView":1383
+ *     for i in range(shape[0]):
+ *         if ndim == 1:
+ *             if inc:             # <<<<<<<<<<<<<<
+ *                 Py_INCREF(( data)[0])
+ *             else:
+ */
+      __pyx_t_4 = (__pyx_v_inc != 0);
+      if (__pyx_t_4) {
+
+        /* "View.MemoryView":1384
+ *         if ndim == 1:
+ *             if inc:
+ *                 Py_INCREF(( data)[0])             # <<<<<<<<<<<<<<
+ *             else:
+ *                 Py_DECREF(( data)[0])
+ */
+        Py_INCREF((((PyObject **)__pyx_v_data)[0]));
+
+        /* "View.MemoryView":1383
+ *     for i in range(shape[0]):
+ *         if ndim == 1:
+ *             if inc:             # <<<<<<<<<<<<<<
+ *                 Py_INCREF(( data)[0])
+ *             else:
+ */
+        goto __pyx_L6;
+      }
+
+      /* "View.MemoryView":1386
+ *                 Py_INCREF(( data)[0])
+ *             else:
+ *                 Py_DECREF(( data)[0])             # <<<<<<<<<<<<<<
+ *         else:
+ *             refcount_objects_in_slice(data, shape + 1, strides + 1,
+ */
+      /*else*/ {
+        Py_DECREF((((PyObject **)__pyx_v_data)[0]));
+      }
+      __pyx_L6:;
+
+      /* "View.MemoryView":1382
+ * 
+ *     for i in range(shape[0]):
+ *         if ndim == 1:             # <<<<<<<<<<<<<<
+ *             if inc:
+ *                 Py_INCREF(( data)[0])
+ */
+      goto __pyx_L5;
+    }
+
+    /* "View.MemoryView":1388
+ *                 Py_DECREF(( data)[0])
+ *         else:
+ *             refcount_objects_in_slice(data, shape + 1, strides + 1,             # <<<<<<<<<<<<<<
+ *                                       ndim - 1, inc)
+ * 
+ */
+    /*else*/ {
+
+      /* "View.MemoryView":1389
+ *         else:
+ *             refcount_objects_in_slice(data, shape + 1, strides + 1,
+ *                                       ndim - 1, inc)             # <<<<<<<<<<<<<<
+ * 
+ *         data += strides[0]
+ */
+      __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc);
+    }
+    __pyx_L5:;
+
+    /* "View.MemoryView":1391
+ *                                       ndim - 1, inc)
+ * 
+ *         data += strides[0]             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0]));
+  }
+
+  /* "View.MemoryView":1377
+ * 
+ * @cname('__pyx_memoryview_refcount_objects_in_slice')
+ * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
+ *                                     Py_ssize_t *strides, int ndim, bint inc):
+ *     cdef Py_ssize_t i
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "View.MemoryView":1397
+ * 
+ * @cname('__pyx_memoryview_slice_assign_scalar')
+ * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim,             # <<<<<<<<<<<<<<
+ *                               size_t itemsize, void *item,
+ *                               bint dtype_is_object) nogil:
+ */
+
+static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) {
+
+  /* "View.MemoryView":1400
+ *                               size_t itemsize, void *item,
+ *                               bint dtype_is_object) nogil:
+ *     refcount_copying(dst, dtype_is_object, ndim, False)             # <<<<<<<<<<<<<<
+ *     _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,
+ *                          itemsize, item)
+ */
+  __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0);
+
+  /* "View.MemoryView":1401
+ *                               bint dtype_is_object) nogil:
+ *     refcount_copying(dst, dtype_is_object, ndim, False)
+ *     _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,             # <<<<<<<<<<<<<<
+ *                          itemsize, item)
+ *     refcount_copying(dst, dtype_is_object, ndim, True)
+ */
+  __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item);
+
+  /* "View.MemoryView":1403
+ *     _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,
+ *                          itemsize, item)
+ *     refcount_copying(dst, dtype_is_object, ndim, True)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1);
+
+  /* "View.MemoryView":1397
+ * 
+ * @cname('__pyx_memoryview_slice_assign_scalar')
+ * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim,             # <<<<<<<<<<<<<<
+ *                               size_t itemsize, void *item,
+ *                               bint dtype_is_object) nogil:
+ */
+
+  /* function exit code */
+}
+
+/* "View.MemoryView":1407
+ * 
+ * @cname('__pyx_memoryview__slice_assign_scalar')
+ * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
+ *                               Py_ssize_t *strides, int ndim,
+ *                               size_t itemsize, void *item) nogil:
+ */
+
+static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) {
+  CYTHON_UNUSED Py_ssize_t __pyx_v_i;
+  Py_ssize_t __pyx_v_stride;
+  Py_ssize_t __pyx_v_extent;
+  int __pyx_t_1;
+  Py_ssize_t __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+
+  /* "View.MemoryView":1411
+ *                               size_t itemsize, void *item) nogil:
+ *     cdef Py_ssize_t i
+ *     cdef Py_ssize_t stride = strides[0]             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t extent = shape[0]
+ * 
+ */
+  __pyx_v_stride = (__pyx_v_strides[0]);
+
+  /* "View.MemoryView":1412
+ *     cdef Py_ssize_t i
+ *     cdef Py_ssize_t stride = strides[0]
+ *     cdef Py_ssize_t extent = shape[0]             # <<<<<<<<<<<<<<
+ * 
+ *     if ndim == 1:
+ */
+  __pyx_v_extent = (__pyx_v_shape[0]);
+
+  /* "View.MemoryView":1414
+ *     cdef Py_ssize_t extent = shape[0]
+ * 
+ *     if ndim == 1:             # <<<<<<<<<<<<<<
+ *         for i in range(extent):
+ *             memcpy(data, item, itemsize)
+ */
+  __pyx_t_1 = ((__pyx_v_ndim == 1) != 0);
+  if (__pyx_t_1) {
+
+    /* "View.MemoryView":1415
+ * 
+ *     if ndim == 1:
+ *         for i in range(extent):             # <<<<<<<<<<<<<<
+ *             memcpy(data, item, itemsize)
+ *             data += stride
+ */
+    __pyx_t_2 = __pyx_v_extent;
+    __pyx_t_3 = __pyx_t_2;
+    for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+      __pyx_v_i = __pyx_t_4;
+
+      /* "View.MemoryView":1416
+ *     if ndim == 1:
+ *         for i in range(extent):
+ *             memcpy(data, item, itemsize)             # <<<<<<<<<<<<<<
+ *             data += stride
+ *     else:
+ */
+      (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize));
+
+      /* "View.MemoryView":1417
+ *         for i in range(extent):
+ *             memcpy(data, item, itemsize)
+ *             data += stride             # <<<<<<<<<<<<<<
+ *     else:
+ *         for i in range(extent):
+ */
+      __pyx_v_data = (__pyx_v_data + __pyx_v_stride);
+    }
+
+    /* "View.MemoryView":1414
+ *     cdef Py_ssize_t extent = shape[0]
+ * 
+ *     if ndim == 1:             # <<<<<<<<<<<<<<
+ *         for i in range(extent):
+ *             memcpy(data, item, itemsize)
+ */
+    goto __pyx_L3;
+  }
+
+  /* "View.MemoryView":1419
+ *             data += stride
+ *     else:
+ *         for i in range(extent):             # <<<<<<<<<<<<<<
+ *             _slice_assign_scalar(data, shape + 1, strides + 1,
+ *                                 ndim - 1, itemsize, item)
+ */
+  /*else*/ {
+    __pyx_t_2 = __pyx_v_extent;
+    __pyx_t_3 = __pyx_t_2;
+    for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+      __pyx_v_i = __pyx_t_4;
+
+      /* "View.MemoryView":1420
+ *     else:
+ *         for i in range(extent):
+ *             _slice_assign_scalar(data, shape + 1, strides + 1,             # <<<<<<<<<<<<<<
+ *                                 ndim - 1, itemsize, item)
+ *             data += stride
+ */
+      __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item);
+
+      /* "View.MemoryView":1422
+ *             _slice_assign_scalar(data, shape + 1, strides + 1,
+ *                                 ndim - 1, itemsize, item)
+ *             data += stride             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+      __pyx_v_data = (__pyx_v_data + __pyx_v_stride);
+    }
+  }
+  __pyx_L3:;
+
+  /* "View.MemoryView":1407
+ * 
+ * @cname('__pyx_memoryview__slice_assign_scalar')
+ * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape,             # <<<<<<<<<<<<<<
+ *                               Py_ssize_t *strides, int ndim,
+ *                               size_t itemsize, void *item) nogil:
+ */
+
+  /* function exit code */
+}
+
+/* "(tree fragment)":1
+ * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v___pyx_type = 0;
+  long __pyx_v___pyx_checksum;
+  PyObject *__pyx_v___pyx_state = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(2, 1, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(2, 1, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(2, 1, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v___pyx_type = values[0];
+    __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(2, 1, __pyx_L3_error)
+    __pyx_v___pyx_state = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_v___pyx_PickleError = 0;
+  PyObject *__pyx_v___pyx_result = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0);
+
+  /* "(tree fragment)":4
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0xb068931:             # <<<<<<<<<<<<<<
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
+ */
+  __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0);
+  if (__pyx_t_1) {
+
+    /* "(tree fragment)":5
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0xb068931:
+ *         from pickle import PickleError as __pyx_PickleError             # <<<<<<<<<<<<<<
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
+ *     __pyx_result = Enum.__new__(__pyx_type)
+ */
+    __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_n_s_PickleError);
+    __Pyx_GIVEREF(__pyx_n_s_PickleError);
+    PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError);
+    __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 5, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_v___pyx_PickleError = __pyx_t_2;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "(tree fragment)":6
+ *     if __pyx_checksum != 0xb068931:
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)             # <<<<<<<<<<<<<<
+ *     __pyx_result = Enum.__new__(__pyx_type)
+ *     if __pyx_state is not None:
+ */
+    __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_INCREF(__pyx_v___pyx_PickleError);
+    __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_5)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 6, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 6, __pyx_L1_error)
+
+    /* "(tree fragment)":4
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ *     if __pyx_checksum != 0xb068931:             # <<<<<<<<<<<<<<
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
+ */
+  }
+
+  /* "(tree fragment)":7
+ *         from pickle import PickleError as __pyx_PickleError
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
+ *     __pyx_result = Enum.__new__(__pyx_type)             # <<<<<<<<<<<<<<
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v___pyx_result = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+  /* "(tree fragment)":8
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
+ *     __pyx_result = Enum.__new__(__pyx_type)
+ *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
+ *         __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ */
+  __pyx_t_1 = (__pyx_v___pyx_state != Py_None);
+  __pyx_t_6 = (__pyx_t_1 != 0);
+  if (__pyx_t_6) {
+
+    /* "(tree fragment)":9
+ *     __pyx_result = Enum.__new__(__pyx_type)
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state)             # <<<<<<<<<<<<<<
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
+ */
+    if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 9, __pyx_L1_error)
+    __pyx_t_3 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 9, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+    /* "(tree fragment)":8
+ *         raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum)
+ *     __pyx_result = Enum.__new__(__pyx_type)
+ *     if __pyx_state is not None:             # <<<<<<<<<<<<<<
+ *         __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ */
+  }
+
+  /* "(tree fragment)":10
+ *     if __pyx_state is not None:
+ *         __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result             # <<<<<<<<<<<<<<
+ * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
+ *     __pyx_result.name = __pyx_state[0]
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v___pyx_result);
+  __pyx_r = __pyx_v___pyx_result;
+  goto __pyx_L0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v___pyx_PickleError);
+  __Pyx_XDECREF(__pyx_v___pyx_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":11
+ *         __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.name = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ */
+
+static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0);
+
+  /* "(tree fragment)":12
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
+ *     __pyx_result.name = __pyx_state[0]             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[1])
+ */
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+    __PYX_ERR(2, 12, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __Pyx_GOTREF(__pyx_v___pyx_result->name);
+  __Pyx_DECREF(__pyx_v___pyx_result->name);
+  __pyx_v___pyx_result->name = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "(tree fragment)":13
+ * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
+ *     __pyx_result.name = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
+ *         __pyx_result.__dict__.update(__pyx_state[1])
+ */
+  if (unlikely(__pyx_v___pyx_state == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(2, 13, __pyx_L1_error)
+  }
+  __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 13, __pyx_L1_error)
+  __pyx_t_4 = ((__pyx_t_3 > 1) != 0);
+  if (__pyx_t_4) {
+  } else {
+    __pyx_t_2 = __pyx_t_4;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 13, __pyx_L1_error)
+  __pyx_t_5 = (__pyx_t_4 != 0);
+  __pyx_t_2 = __pyx_t_5;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_2) {
+
+    /* "(tree fragment)":14
+ *     __pyx_result.name = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[1])             # <<<<<<<<<<<<<<
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(__pyx_v___pyx_state == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(2, 14, __pyx_L1_error)
+    }
+    __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+      }
+    }
+    __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "(tree fragment)":13
+ * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):
+ *     __pyx_result.name = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):             # <<<<<<<<<<<<<<
+ *         __pyx_result.__dict__.update(__pyx_state[1])
+ */
+  }
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.name = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *__pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____object___to_py[8];
+static int __pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py = 0;
+
+static PyObject *__pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____object___to_py(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py)))) {
+    o = (PyObject*)__pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____object___to_py[--__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py];
+    memset(o, 0, sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py));
+    (void) PyObject_INIT(o, t);
+  } else {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  return o;
+}
+
+static void __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_object____object___to_py(PyObject *o) {
+  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py)))) {
+    __pyx_freelist___pyx_scope_struct____Pyx_CFunc_object____object___to_py[__pyx_freecount___pyx_scope_struct____Pyx_CFunc_object____object___to_py++] = ((struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py *)o);
+  } else {
+    (*Py_TYPE(o)->tp_free)(o);
+  }
+}
+
+static PyTypeObject __pyx_scope_struct____Pyx_CFunc_object____object___to_py = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "prange_saliency_mbd.__pyx_scope_struct____Pyx_CFunc_object____object___to_py", /*tp_name*/
+  sizeof(struct __pyx_obj___pyx_scope_struct____Pyx_CFunc_object____object___to_py), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc___pyx_scope_struct____Pyx_CFunc_object____object___to_py, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new___pyx_scope_struct____Pyx_CFunc_object____object___to_py, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_array __pyx_vtable_array;
+
+static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_array_obj *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_array_obj *)o);
+  p->__pyx_vtab = __pyx_vtabptr_array;
+  p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_array(PyObject *o) {
+  struct __pyx_array_obj *p = (struct __pyx_array_obj *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
+    __pyx_array___dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->mode);
+  Py_CLEAR(p->_format);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) {
+  if (v) {
+    return __pyx_array___setitem__(o, i, v);
+  }
+  else {
+    PyErr_Format(PyExc_NotImplementedError,
+      "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);
+    return -1;
+  }
+}
+
+static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) {
+  PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n);
+  if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+    PyErr_Clear();
+    v = __pyx_array___getattr__(o, n);
+  }
+  return v;
+}
+
+static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_array[] = {
+  {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_array[] = {
+  {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_array = {
+  __pyx_array___len__, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_array, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  0, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_array = {
+  __pyx_array___len__, /*mp_length*/
+  __pyx_array___getitem__, /*mp_subscript*/
+  __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/
+};
+
+static PyBufferProcs __pyx_tp_as_buffer_array = {
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getreadbuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getwritebuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getsegcount*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getcharbuffer*/
+  #endif
+  __pyx_array_getbuffer, /*bf_getbuffer*/
+  0, /*bf_releasebuffer*/
+};
+
+static PyTypeObject __pyx_type___pyx_array = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "prange_saliency_mbd.array", /*tp_name*/
+  sizeof(struct __pyx_array_obj), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_array, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  &__pyx_tp_as_sequence_array, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_array, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  __pyx_tp_getattro_array, /*tp_getattro*/
+  0, /*tp_setattro*/
+  &__pyx_tp_as_buffer_array, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_array, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_array, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_array, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_MemviewEnum_obj *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_MemviewEnum_obj *)o);
+  p->name = Py_None; Py_INCREF(Py_None);
+  return o;
+}
+
+static void __pyx_tp_dealloc_Enum(PyObject *o) {
+  struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->name);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
+  if (p->name) {
+    e = (*v)(p->name, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_Enum(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o;
+  tmp = ((PyObject*)p->name);
+  p->name = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
+
+static PyMethodDef __pyx_methods_Enum[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type___pyx_MemviewEnum = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "prange_saliency_mbd.Enum", /*tp_name*/
+  sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_Enum, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_MemviewEnum___repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_Enum, /*tp_traverse*/
+  __pyx_tp_clear_Enum, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_Enum, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  __pyx_MemviewEnum___init__, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_Enum, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview;
+
+static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_memoryview_obj *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_memoryview_obj *)o);
+  p->__pyx_vtab = __pyx_vtabptr_memoryview;
+  p->obj = Py_None; Py_INCREF(Py_None);
+  p->_size = Py_None; Py_INCREF(Py_None);
+  p->_array_interface = Py_None; Py_INCREF(Py_None);
+  p->view.obj = NULL;
+  if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_memoryview(PyObject *o) {
+  struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  PyObject_GC_UnTrack(o);
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
+    __pyx_memoryview___dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->obj);
+  Py_CLEAR(p->_size);
+  Py_CLEAR(p->_array_interface);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
+  if (p->obj) {
+    e = (*v)(p->obj, a); if (e) return e;
+  }
+  if (p->_size) {
+    e = (*v)(p->_size, a); if (e) return e;
+  }
+  if (p->_array_interface) {
+    e = (*v)(p->_array_interface, a); if (e) return e;
+  }
+  if (p->view.obj) {
+    e = (*v)(p->view.obj, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear_memoryview(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o;
+  tmp = ((PyObject*)p->obj);
+  p->obj = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_size);
+  p->_size = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  tmp = ((PyObject*)p->_array_interface);
+  p->_array_interface = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  Py_CLEAR(p->view.obj);
+  return 0;
+}
+static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) {
+  if (v) {
+    return __pyx_memoryview___setitem__(o, i, v);
+  }
+  else {
+    PyErr_Format(PyExc_NotImplementedError,
+      "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o);
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o);
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o);
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o);
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o);
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o);
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o);
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o);
+}
+
+static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_memoryview[] = {
+  {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0},
+  {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0},
+  {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0},
+  {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0},
+  {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_memoryview[] = {
+  {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0},
+  {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0},
+  {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0},
+  {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0},
+  {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0},
+  {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0},
+  {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0},
+  {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0},
+  {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_memoryview = {
+  __pyx_memoryview___len__, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_memoryview, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  0, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_memoryview = {
+  __pyx_memoryview___len__, /*mp_length*/
+  __pyx_memoryview___getitem__, /*mp_subscript*/
+  __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/
+};
+
+static PyBufferProcs __pyx_tp_as_buffer_memoryview = {
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getreadbuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getwritebuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getsegcount*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getcharbuffer*/
+  #endif
+  __pyx_memoryview_getbuffer, /*bf_getbuffer*/
+  0, /*bf_releasebuffer*/
+};
+
+static PyTypeObject __pyx_type___pyx_memoryview = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "prange_saliency_mbd.memoryview", /*tp_name*/
+  sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_memoryview, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_memoryview___repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  __pyx_memoryview___str__, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_memoryview, /*tp_traverse*/
+  __pyx_tp_clear_memoryview, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_memoryview, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_memoryview, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_memoryview, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice;
+
+static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_memoryviewslice_obj *p;
+  PyObject *o = __pyx_tp_new_memoryview(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_memoryviewslice_obj *)o);
+  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice;
+  p->from_object = Py_None; Py_INCREF(Py_None);
+  p->from_slice.memview = NULL;
+  return o;
+}
+
+static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) {
+  struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  PyObject_GC_UnTrack(o);
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
+    __pyx_memoryviewslice___dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->from_object);
+  PyObject_GC_Track(o);
+  __pyx_tp_dealloc_memoryview(o);
+}
+
+static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
+  e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e;
+  if (p->from_object) {
+    e = (*v)(p->from_object, a); if (e) return e;
+  }
+  return 0;
+}
+
+static int __pyx_tp_clear__memoryviewslice(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o;
+  __pyx_tp_clear_memoryview(o);
+  tmp = ((PyObject*)p->from_object);
+  p->from_object = Py_None; Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  __PYX_XDEC_MEMVIEW(&p->from_slice, 1);
+  return 0;
+}
+
+static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods__memoryviewslice[] = {
+  {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0},
+  {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = {
+  {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type___pyx_memoryviewslice = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "prange_saliency_mbd._memoryviewslice", /*tp_name*/
+  sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_memoryview___repr__, /*tp_repr*/
+  #else
+  0, /*tp_repr*/
+  #endif
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  #if CYTHON_COMPILING_IN_PYPY
+  __pyx_memoryview___str__, /*tp_str*/
+  #else
+  0, /*tp_str*/
+  #endif
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+  "Internal class for passing memoryview slices to Python", /*tp_doc*/
+  __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/
+  __pyx_tp_clear__memoryviewslice, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods__memoryviewslice, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets__memoryviewslice, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new__memoryviewslice, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1
+  0, /*tp_vectorcall*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  0, /*tp_print*/
+  #endif
+};
+
+static PyMethodDef __pyx_methods[] = {
+  {"get_saliency_mbd", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_19prange_saliency_mbd_1get_saliency_mbd, METH_VARARGS|METH_KEYWORDS, 0},
+  {0, 0, 0, 0}
+};
+
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_prange_saliency_mbd(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_prange_saliency_mbd},
+  {0, NULL}
+};
+#endif
+
+static struct PyModuleDef __pyx_moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "prange_saliency_mbd",
+    0, /* m_doc */
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+    0, /* m_size */
+  #else
+    -1, /* m_size */
+  #endif
+    __pyx_methods /* m_methods */,
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+    __pyx_moduledef_slots, /* m_slots */
+  #else
+    NULL, /* m_reload */
+  #endif
+    NULL, /* m_traverse */
+    NULL, /* m_clear */
+    NULL /* m_free */
+};
+#endif
+#ifndef CYTHON_SMALL_CODE
+#if defined(__clang__)
+    #define CYTHON_SMALL_CODE
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+    #define CYTHON_SMALL_CODE __attribute__((cold))
+#else
+    #define CYTHON_SMALL_CODE
+#endif
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1},
+  {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0},
+  {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0},
+  {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0},
+  {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0},
+  {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0},
+  {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1},
+  {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0},
+  {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
+  {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
+  {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1},
+  {&__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 0, 0, 1, 0},
+  {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1},
+  {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0},
+  {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0},
+  {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0},
+  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+  {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0},
+  {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0},
+  {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
+  {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1},
+  {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0},
+  {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1},
+  {&__pyx_n_s_Pyx_CFunc_object____object___t, __pyx_k_Pyx_CFunc_object____object___t, sizeof(__pyx_k_Pyx_CFunc_object____object___t), 0, 0, 1, 1},
+  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
+  {&__pyx_n_s_T, __pyx_k_T, sizeof(__pyx_k_T), 0, 0, 1, 1},
+  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+  {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0},
+  {&__pyx_n_s_VI, __pyx_k_VI, sizeof(__pyx_k_VI), 0, 0, 1, 1},
+  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+  {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1},
+  {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1},
+  {&__pyx_n_s_arange, __pyx_k_arange, sizeof(__pyx_k_arange), 0, 0, 1, 1},
+  {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1},
+  {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1},
+  {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1},
+  {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1},
+  {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1},
+  {&__pyx_n_s_cdist, __pyx_k_cdist, sizeof(__pyx_k_cdist), 0, 0, 1, 1},
+  {&__pyx_n_s_cfunc_to_py, __pyx_k_cfunc_to_py, sizeof(__pyx_k_cfunc_to_py), 0, 0, 1, 1},
+  {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1},
+  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+  {&__pyx_n_s_color, __pyx_k_color, sizeof(__pyx_k_color), 0, 0, 1, 1},
+  {&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0},
+  {&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0},
+  {&__pyx_n_s_cov, __pyx_k_cov, sizeof(__pyx_k_cov), 0, 0, 1, 1},
+  {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1},
+  {&__pyx_n_s_distance, __pyx_k_distance, sizeof(__pyx_k_distance), 0, 0, 1, 1},
+  {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1},
+  {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1},
+  {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
+  {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1},
+  {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1},
+  {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
+  {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1},
+  {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1},
+  {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1},
+  {&__pyx_n_s_full_like, __pyx_k_full_like, sizeof(__pyx_k_full_like), 0, 0, 1, 1},
+  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+  {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0},
+  {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1},
+  {&__pyx_n_s_img, __pyx_k_img, sizeof(__pyx_k_img), 0, 0, 1, 1},
+  {&__pyx_n_s_img_as_float, __pyx_k_img_as_float, sizeof(__pyx_k_img_as_float), 0, 0, 1, 1},
+  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+  {&__pyx_n_s_inv, __pyx_k_inv, sizeof(__pyx_k_inv), 0, 0, 1, 1},
+  {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1},
+  {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0},
+  {&__pyx_n_s_linalg, __pyx_k_linalg, sizeof(__pyx_k_linalg), 0, 0, 1, 1},
+  {&__pyx_n_s_mahalanobis, __pyx_k_mahalanobis, sizeof(__pyx_k_mahalanobis), 0, 0, 1, 1},
+  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+  {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1},
+  {&__pyx_n_s_maximum, __pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 0, 1, 1},
+  {&__pyx_n_s_mean, __pyx_k_mean, sizeof(__pyx_k_mean), 0, 0, 1, 1},
+  {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1},
+  {&__pyx_n_s_meshgrid, __pyx_k_meshgrid, sizeof(__pyx_k_meshgrid), 0, 0, 1, 1},
+  {&__pyx_n_s_method, __pyx_k_method, sizeof(__pyx_k_method), 0, 0, 1, 1},
+  {&__pyx_n_s_minimize, __pyx_k_minimize, sizeof(__pyx_k_minimize), 0, 0, 1, 1},
+  {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
+  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+  {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
+  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
+  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
+  {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1},
+  {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1},
+  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+  {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
+  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
+  {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0},
+  {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0},
+  {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1},
+  {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1},
+  {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1},
+  {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1},
+  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+  {&__pyx_n_s_res, __pyx_k_res, sizeof(__pyx_k_res), 0, 0, 1, 1},
+  {&__pyx_n_s_reshape, __pyx_k_reshape, sizeof(__pyx_k_reshape), 0, 0, 1, 1},
+  {&__pyx_n_s_rgb2lab, __pyx_k_rgb2lab, sizeof(__pyx_k_rgb2lab), 0, 0, 1, 1},
+  {&__pyx_n_s_scipy, __pyx_k_scipy, sizeof(__pyx_k_scipy), 0, 0, 1, 1},
+  {&__pyx_n_s_scipy_optimize, __pyx_k_scipy_optimize, sizeof(__pyx_k_scipy_optimize), 0, 0, 1, 1},
+  {&__pyx_n_s_scipy_spatial_distance, __pyx_k_scipy_spatial_distance, sizeof(__pyx_k_scipy_spatial_distance), 0, 0, 1, 1},
+  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+  {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1},
+  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
+  {&__pyx_n_s_skimage, __pyx_k_skimage, sizeof(__pyx_k_skimage), 0, 0, 1, 1},
+  {&__pyx_n_s_skimage_io, __pyx_k_skimage_io, sizeof(__pyx_k_skimage_io), 0, 0, 1, 1},
+  {&__pyx_n_s_skimage_util, __pyx_k_skimage_util, sizeof(__pyx_k_skimage_util), 0, 0, 1, 1},
+  {&__pyx_n_s_spatial, __pyx_k_spatial, sizeof(__pyx_k_spatial), 0, 0, 1, 1},
+  {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1},
+  {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1},
+  {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1},
+  {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1},
+  {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0},
+  {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0},
+  {&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0},
+  {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+  {&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1},
+  {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1},
+  {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1},
+  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+  {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0},
+  {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0},
+  {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
+  {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1},
+  {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1},
+  {&__pyx_n_s_vectorize, __pyx_k_vectorize, sizeof(__pyx_k_vectorize), 0, 0, 1, 1},
+  {&__pyx_n_s_wrap, __pyx_k_wrap, sizeof(__pyx_k_wrap), 0, 0, 1, 1},
+  {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1},
+  {&__pyx_n_s_xrange, __pyx_k_xrange, sizeof(__pyx_k_xrange), 0, 0, 1, 1},
+  {0, 0, 0, 0, 0, 0, 0}
+};
+static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
+  #if PY_MAJOR_VERSION >= 3
+  __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_xrange) __PYX_ERR(0, 32, __pyx_L1_error)
+  #else
+  __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_xrange); if (!__pyx_builtin_xrange) __PYX_ERR(0, 32, __pyx_L1_error)
+  #endif
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 285, __pyx_L1_error)
+  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 855, __pyx_L1_error)
+  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1037, __pyx_L1_error)
+  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(2, 148, __pyx_L1_error)
+  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(2, 151, __pyx_L1_error)
+  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(2, 2, __pyx_L1_error)
+  __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(2, 404, __pyx_L1_error)
+  __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(2, 613, __pyx_L1_error)
+  __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(2, 832, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+
+  /* "prange_saliency_mbd.pyx":124
+ * 	cdef double [:,:] U = img[...]
+ * 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
+ * 	D[0,:] = 0             # <<<<<<<<<<<<<<
+ * 	D[-1,:] = 0
+ * 	D[:,0] = 0
+ */
+  __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
+  __pyx_tuple__2 = PyTuple_Pack(2, __pyx_int_0, __pyx_slice_); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+
+  /* "prange_saliency_mbd.pyx":125
+ * 	cdef np.ndarray[double, ndim=2] D = np.full_like(img, 10000000)
+ * 	D[0,:] = 0
+ * 	D[-1,:] = 0             # <<<<<<<<<<<<<<
+ * 	D[:,0] = 0
+ * 	D[:,-1] = 0
+ */
+  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_neg_1, __pyx_slice_); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+
+  /* "prange_saliency_mbd.pyx":126
+ * 	D[0,:] = 0
+ * 	D[-1,:] = 0
+ * 	D[:,0] = 0             # <<<<<<<<<<<<<<
+ * 	D[:,-1] = 0
+ * 
+ */
+  __pyx_tuple__4 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_0); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+
+  /* "prange_saliency_mbd.pyx":127
+ * 	D[-1,:] = 0
+ * 	D[:,0] = 0
+ * 	D[:,-1] = 0             # <<<<<<<<<<<<<<
+ * 
+ * 	cdef int x
+ */
+  __pyx_tuple__5 = PyTuple_Pack(2, __pyx_slice_, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
+  /* "prange_saliency_mbd.pyx":141
+ * 	x, v2 = val
+ * 	px, cov, px_mean = v2
+ * 	px_mean[x] = np.mean(px[x],axis=(0,1))             # <<<<<<<<<<<<<<
+ * 	px[x] = px[x].reshape((n_cols*border_thickness,3))
+ * 	cov[x] =  np.linalg.inv(np.cov(px[x].T))
+ */
+  __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+
+  /* "prange_saliency_mbd.pyx":175
+ * 	# cdef px = [px_1,px_2]
+ * 
+ * 	cdef  np.ndarray[double,ndim=2] px_mean = np.empty((4,3)) ## np.ndarray[double,ndim=2]             # <<<<<<<<<<<<<<
+ * 	cdef  np.ndarray[double,ndim=3] cov = np.empty((4,3,3))
+ * 	cdef np.ndarray[double,ndim=3] px_new_1 = np.empty((2, n_cols*border_thickness,3))
+ */
+  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_4, __pyx_int_3); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+
+  /* "prange_saliency_mbd.pyx":176
+ * 
+ * 	cdef  np.ndarray[double,ndim=2] px_mean = np.empty((4,3)) ## np.ndarray[double,ndim=2]
+ * 	cdef  np.ndarray[double,ndim=3] cov = np.empty((4,3,3))             # <<<<<<<<<<<<<<
+ * 	cdef np.ndarray[double,ndim=3] px_new_1 = np.empty((2, n_cols*border_thickness,3))
+ * 	cdef np.ndarray[double,ndim=3] px_new_2  = np.empty((2, n_rows*border_thickness,3))
+ */
+  __pyx_tuple__8 = PyTuple_Pack(3, __pyx_int_4, __pyx_int_3, __pyx_int_3); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+
+  /* "prange_saliency_mbd.pyx":200
+ * 
+ * 	cdef np.ndarray[double,ndim=2] img_lab_unrolled = img_lab.reshape(img_lab.shape[0]*img_lab.shape[1],3)
+ * 	cdef np.ndarray[double,ndim=3] px_mean_2 = np.empty((4,1,3))             # <<<<<<<<<<<<<<
+ * 	for x in xrange(4):
+ * 		px_mean_2[x,0] = px_mean[x]
+ */
+  __pyx_tuple__9 = PyTuple_Pack(3, __pyx_int_4, __pyx_int_1, __pyx_int_3); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 272, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 276, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 306, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855
+ * 
+ *         if (end - f) - (new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 855, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 879, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 1037, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+
+  /* "../../../../../../../opt/anaconda3/envs/urobotics/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 1043, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+
+  /* "cfunc.to_py":65
+ * @cname("__Pyx_CFunc_object____object___to_py")
+ * cdef object __Pyx_CFunc_object____object___to_py(object (*f)(object) ):
+ *     def wrap(object x):             # <<<<<<<<<<<<<<
+ *         """wrap(x)"""
+ *         return f(x)
+ */
+  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(2, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+  __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_wrap, 65, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(2, 65, __pyx_L1_error)
+
+  /* "View.MemoryView":133
+ * 
+ *         if not self.ndim:
+ *             raise ValueError("Empty shape tuple for cython.array")             # <<<<<<<<<<<<<<
+ * 
+ *         if itemsize <= 0:
+ */
+  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(2, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
+
+  /* "View.MemoryView":136
+ * 
+ *         if itemsize <= 0:
+ *             raise ValueError("itemsize <= 0 for cython.array")             # <<<<<<<<<<<<<<
+ * 
+ *         if not isinstance(format, bytes):
+ */
+  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(2, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__20);
+  __Pyx_GIVEREF(__pyx_tuple__20);
+
+  /* "View.MemoryView":148
+ * 
+ *         if not self._shape:
+ *             raise MemoryError("unable to allocate shape and strides.")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(2, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
+
+  /* "View.MemoryView":176
+ *             self.data = malloc(self.len)
+ *             if not self.data:
+ *                 raise MemoryError("unable to allocate array data.")             # <<<<<<<<<<<<<<
+ * 
+ *             if self.dtype_is_object:
+ */
+  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(2, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__22);
+  __Pyx_GIVEREF(__pyx_tuple__22);
+
+  /* "View.MemoryView":192
+ *             bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
+ *         if not (flags & bufmode):
+ *             raise ValueError("Can only create a buffer that is contiguous in memory.")             # <<<<<<<<<<<<<<
+ *         info.buf = self.data
+ *         info.len = self.len
+ */
+  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(2, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
+
+  /* "View.MemoryView":418
+ *     def __setitem__(memoryview self, object index, object value):
+ *         if self.view.readonly:
+ *             raise TypeError("Cannot assign to read-only memoryview")             # <<<<<<<<<<<<<<
+ * 
+ *         have_slices, index = _unellipsify(index, self.view.ndim)
+ */
+  __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(2, 418, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__26);
+  __Pyx_GIVEREF(__pyx_tuple__26);
+
+  /* "View.MemoryView":495
+ *             result = struct.unpack(self.view.format, bytesitem)
+ *         except struct.error:
+ *             raise ValueError("Unable to convert item to object")             # <<<<<<<<<<<<<<
+ *         else:
+ *             if len(self.view.format) == 1:
+ */
+  __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(2, 495, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+
+  /* "View.MemoryView":520
+ *     def __getbuffer__(self, Py_buffer *info, int flags):
+ *         if flags & PyBUF_WRITABLE and self.view.readonly:
+ *             raise ValueError("Cannot create writable memory view from read-only memoryview")             # <<<<<<<<<<<<<<
+ * 
+ *         if flags & PyBUF_ND:
+ */
+  __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(2, 520, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__28);
+  __Pyx_GIVEREF(__pyx_tuple__28);
+
+  /* "View.MemoryView":570
+ *         if self.view.strides == NULL:
+ * 
+ *             raise ValueError("Buffer view does not expose strides")             # <<<<<<<<<<<<<<
+ * 
+ *         return tuple([stride for stride in self.view.strides[:self.view.ndim]])
+ */
+  __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(2, 570, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__29);
+  __Pyx_GIVEREF(__pyx_tuple__29);
+
+  /* "View.MemoryView":577
+ *     def suboffsets(self):
+ *         if self.view.suboffsets == NULL:
+ *             return (-1,) * self.view.ndim             # <<<<<<<<<<<<<<
+ * 
+ *         return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
+ */
+  __pyx_tuple__30 = PyTuple_New(1); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(2, 577, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__30);
+  __Pyx_INCREF(__pyx_int_neg_1);
+  __Pyx_GIVEREF(__pyx_int_neg_1);
+  PyTuple_SET_ITEM(__pyx_tuple__30, 0, __pyx_int_neg_1);
+  __Pyx_GIVEREF(__pyx_tuple__30);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+  __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__31);
+  __Pyx_GIVEREF(__pyx_tuple__31);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__32);
+  __Pyx_GIVEREF(__pyx_tuple__32);
+
+  /* "View.MemoryView":703
+ *     for suboffset in suboffsets[:ndim]:
+ *         if suboffset >= 0:
+ *             raise ValueError("Indirect dimensions not supported")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(2, 703, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__33);
+  __Pyx_GIVEREF(__pyx_tuple__33);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ */
+  __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(2, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__34);
+  __Pyx_GIVEREF(__pyx_tuple__34);
+
+  /* "(tree fragment)":4
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__35);
+  __Pyx_GIVEREF(__pyx_tuple__35);
+
+  /* "View.MemoryView":286
+ *         return self.name
+ * 
+ * cdef generic = Enum("")             # <<<<<<<<<<<<<<
+ * cdef strided = Enum("") # default
+ * cdef indirect = Enum("")
+ */
+  __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(2, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__36);
+  __Pyx_GIVEREF(__pyx_tuple__36);
+
+  /* "View.MemoryView":287
+ * 
+ * cdef generic = Enum("")
+ * cdef strided = Enum("") # default             # <<<<<<<<<<<<<<
+ * cdef indirect = Enum("")
+ * 
+ */
+  __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(2, 287, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__37);
+  __Pyx_GIVEREF(__pyx_tuple__37);
+
+  /* "View.MemoryView":288
+ * cdef generic = Enum("")
+ * cdef strided = Enum("") # default
+ * cdef indirect = Enum("")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(2, 288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__38);
+  __Pyx_GIVEREF(__pyx_tuple__38);
+
+  /* "View.MemoryView":291
+ * 
+ * 
+ * cdef contiguous = Enum("")             # <<<<<<<<<<<<<<
+ * cdef indirect_contiguous = Enum("")
+ * 
+ */
+  __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(2, 291, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__39);
+  __Pyx_GIVEREF(__pyx_tuple__39);
+
+  /* "View.MemoryView":292
+ * 
+ * cdef contiguous = Enum("")
+ * cdef indirect_contiguous = Enum("")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(2, 292, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__40);
+  __Pyx_GIVEREF(__pyx_tuple__40);
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_tuple__41 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(2, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__41);
+  __Pyx_GIVEREF(__pyx_tuple__41);
+  __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(2, 1, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  /* InitThreads.init */
+  #ifdef WITH_THREAD
+PyEval_InitThreads();
+#endif
+
+if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_float_0_5 = PyFloat_FromDouble(0.5); if (unlikely(!__pyx_float_0_5)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_float_255_0 = PyFloat_FromDouble(255.0); if (unlikely(!__pyx_float_255_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_10000000 = PyInt_FromLong(10000000L); if (unlikely(!__pyx_int_10000000)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+
+static int __Pyx_modinit_global_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
+  /*--- Global init code ---*/
+  generic = Py_None; Py_INCREF(Py_None);
+  strided = Py_None; Py_INCREF(Py_None);
+  indirect = Py_None; Py_INCREF(Py_None);
+  contiguous = Py_None; Py_INCREF(Py_None);
+  indirect_contiguous = Py_None; Py_INCREF(Py_None);
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_variable_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
+  /*--- Variable export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
+  /*--- Function export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_type_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
+  /*--- Type init code ---*/
+  if (PyType_Ready(&__pyx_scope_struct____Pyx_CFunc_object____object___to_py) < 0) __PYX_ERR(2, 64, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_scope_struct____Pyx_CFunc_object____object___to_py.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_scope_struct____Pyx_CFunc_object____object___to_py.tp_dictoffset && __pyx_scope_struct____Pyx_CFunc_object____object___to_py.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_scope_struct____Pyx_CFunc_object____object___to_py.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  __pyx_ptype___pyx_scope_struct____Pyx_CFunc_object____object___to_py = &__pyx_scope_struct____Pyx_CFunc_object____object___to_py;
+  __pyx_vtabptr_array = &__pyx_vtable_array;
+  __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview;
+  if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(2, 105, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type___pyx_array.tp_print = 0;
+  #endif
+  if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(2, 105, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(2, 105, __pyx_L1_error)
+  __pyx_array_type = &__pyx_type___pyx_array;
+  if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(2, 279, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type___pyx_MemviewEnum.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(2, 279, __pyx_L1_error)
+  __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum;
+  __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview;
+  __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer;
+  __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice;
+  __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment;
+  __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar;
+  __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed;
+  __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object;
+  __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object;
+  if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(2, 330, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type___pyx_memoryview.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(2, 330, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(2, 330, __pyx_L1_error)
+  __pyx_memoryview_type = &__pyx_type___pyx_memoryview;
+  __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice;
+  __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview;
+  __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object;
+  __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object;
+  __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type;
+  if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(2, 965, __pyx_L1_error)
+  #if PY_VERSION_HEX < 0x030800B1
+  __pyx_type___pyx_memoryviewslice.tp_print = 0;
+  #endif
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(2, 965, __pyx_L1_error)
+  if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(2, 965, __pyx_L1_error)
+  __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_type_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
+  /*--- Type import code ---*/
+  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", 
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyTypeObject),
+  #else
+  sizeof(PyHeapTypeObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn);
+   if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore);
+   if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error)
+  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn);
+   if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error)
+  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn);
+   if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error)
+  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore);
+   if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error)
+  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn);
+   if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 917, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_variable_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
+  /*--- Variable import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+
+#ifndef CYTHON_NO_PYINIT_EXPORT
+#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#elif PY_MAJOR_VERSION < 3
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" void
+#else
+#define __Pyx_PyMODINIT_FUNC void
+#endif
+#else
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+#else
+#define __Pyx_PyMODINIT_FUNC PyObject *
+#endif
+#endif
+
+
+#if PY_MAJOR_VERSION < 3
+__Pyx_PyMODINIT_FUNC initprange_saliency_mbd(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC initprange_saliency_mbd(void)
+#else
+__Pyx_PyMODINIT_FUNC PyInit_prange_saliency_mbd(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_prange_saliency_mbd(void)
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+{
+  return PyModuleDef_Init(&__pyx_moduledef);
+}
+static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
+    #if PY_VERSION_HEX >= 0x030700A1
+    static PY_INT64_T main_interpreter_id = -1;
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
+    if (main_interpreter_id == -1) {
+        main_interpreter_id = current_id;
+        return (unlikely(current_id == -1)) ? -1 : 0;
+    } else if (unlikely(main_interpreter_id != current_id))
+    #else
+    static PyInterpreterState *main_interpreter = NULL;
+    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
+    if (!main_interpreter) {
+        main_interpreter = current_interpreter;
+    } else if (unlikely(main_interpreter != current_interpreter))
+    #endif
+    {
+        PyErr_SetString(
+            PyExc_ImportError,
+            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+    PyObject *value = PyObject_GetAttrString(spec, from_name);
+    int result = 0;
+    if (likely(value)) {
+        if (allow_none || value != Py_None) {
+            result = PyDict_SetItemString(moddict, to_name, value);
+        }
+        Py_DECREF(value);
+    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+    } else {
+        result = -1;
+    }
+    return result;
+}
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+    PyObject *module = NULL, *moddict, *modname;
+    if (__Pyx_check_single_interpreter())
+        return NULL;
+    if (__pyx_m)
+        return __Pyx_NewRef(__pyx_m);
+    modname = PyObject_GetAttrString(spec, "name");
+    if (unlikely(!modname)) goto bad;
+    module = PyModule_NewObject(modname);
+    Py_DECREF(modname);
+    if (unlikely(!module)) goto bad;
+    moddict = PyModule_GetDict(module);
+    if (unlikely(!moddict)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
+    return module;
+bad:
+    Py_XDECREF(module);
+    return NULL;
+}
+
+
+static CYTHON_SMALL_CODE int __pyx_pymod_exec_prange_saliency_mbd(PyObject *__pyx_pyinit_module)
+#endif
+#endif
+{
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  static PyThread_type_lock __pyx_t_4[8];
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  if (__pyx_m) {
+    if (__pyx_m == __pyx_pyinit_module) return 0;
+    PyErr_SetString(PyExc_RuntimeError, "Module 'prange_saliency_mbd' has already been imported. Re-initialisation is not supported.");
+    return -1;
+  }
+  #elif PY_MAJOR_VERSION >= 3
+  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
+  #endif
+  #if CYTHON_REFNANNY
+__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+if (!__Pyx_RefNanny) {
+  PyErr_Clear();
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+  if (!__Pyx_RefNanny)
+      Py_FatalError("failed to import 'refnanny' module");
+}
+#endif
+  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_prange_saliency_mbd(void)", 0);
+  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pxy_PyFrame_Initialize_Offsets
+  __Pxy_PyFrame_Initialize_Offsets();
+  #endif
+  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_AsyncGen_USED
+  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_StopAsyncIteration_USED
+  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  /*--- Threads initialization code ---*/
+  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
+  #ifdef WITH_THREAD /* Python build with threading support? */
+  PyEval_InitThreads();
+  #endif
+  #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("prange_saliency_mbd", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  #endif
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_b);
+  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_cython_runtime);
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  if (__pyx_module_is_main_prange_saliency_mbd) {
+    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  }
+  #if PY_MAJOR_VERSION >= 3
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "prange_saliency_mbd")) {
+      if (unlikely(PyDict_SetItemString(modules, "prange_saliency_mbd", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+    }
+  }
+  #endif
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Global type/function init code ---*/
+  (void)__Pyx_modinit_global_init_code();
+  (void)__Pyx_modinit_variable_export_code();
+  (void)__Pyx_modinit_function_export_code();
+  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  (void)__Pyx_modinit_variable_import_code();
+  (void)__Pyx_modinit_function_import_code();
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+
+  /* "prange_saliency_mbd.pyx":1
+ * import sys             # <<<<<<<<<<<<<<
+ * import numpy as np
+ * cimport numpy as np
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":2
+ * import sys
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as np
+ * import scipy.spatial.distance
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":4
+ * import numpy as np
+ * cimport numpy as np
+ * import scipy.spatial.distance             # <<<<<<<<<<<<<<
+ * import skimage
+ * import skimage.io
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_spatial_distance, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_scipy, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":5
+ * cimport numpy as np
+ * import scipy.spatial.distance
+ * import skimage             # <<<<<<<<<<<<<<
+ * import skimage.io
+ * from skimage.util import img_as_float
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":6
+ * import scipy.spatial.distance
+ * import skimage
+ * import skimage.io             # <<<<<<<<<<<<<<
+ * from skimage.util import img_as_float
+ * from scipy.optimize import minimize
+ */
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_skimage_io, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_skimage, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":7
+ * import skimage
+ * import skimage.io
+ * from skimage.util import img_as_float             # <<<<<<<<<<<<<<
+ * from scipy.optimize import minimize
+ * cimport cython
+ */
+  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_n_s_img_as_float);
+  __Pyx_GIVEREF(__pyx_n_s_img_as_float);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_img_as_float);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_skimage_util, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_img_as_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_img_as_float, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "prange_saliency_mbd.pyx":8
+ * import skimage.io
+ * from skimage.util import img_as_float
+ * from scipy.optimize import minimize             # <<<<<<<<<<<<<<
+ * cimport cython
+ * from libc.math cimport exp, floor, sqrt
+ */
+  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_n_s_minimize);
+  __Pyx_GIVEREF(__pyx_n_s_minimize);
+  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_minimize);
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy_optimize, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_minimize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_minimize, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "prange_saliency_mbd.pyx":13
+ * from cython.parallel cimport prange
+ * 
+ * np.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * @cython.boundscheck(False)
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 13, __pyx_L1_error)
+
+  /* "prange_saliency_mbd.pyx":1
+ * import sys             # <<<<<<<<<<<<<<
+ * import numpy as np
+ * cimport numpy as np
+ */
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "View.MemoryView":209
+ *         info.obj = self
+ * 
+ *     __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(array self):
+ */
+  __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(2, 209, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  PyType_Modified(__pyx_array_type);
+
+  /* "View.MemoryView":286
+ *         return self.name
+ * 
+ * cdef generic = Enum("")             # <<<<<<<<<<<<<<
+ * cdef strided = Enum("") # default
+ * cdef indirect = Enum("")
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_XGOTREF(generic);
+  __Pyx_DECREF_SET(generic, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":287
+ * 
+ * cdef generic = Enum("")
+ * cdef strided = Enum("") # default             # <<<<<<<<<<<<<<
+ * cdef indirect = Enum("")
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 287, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_XGOTREF(strided);
+  __Pyx_DECREF_SET(strided, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":288
+ * cdef generic = Enum("")
+ * cdef strided = Enum("") # default
+ * cdef indirect = Enum("")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_XGOTREF(indirect);
+  __Pyx_DECREF_SET(indirect, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":291
+ * 
+ * 
+ * cdef contiguous = Enum("")             # <<<<<<<<<<<<<<
+ * cdef indirect_contiguous = Enum("")
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 291, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_XGOTREF(contiguous);
+  __Pyx_DECREF_SET(contiguous, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":292
+ * 
+ * cdef contiguous = Enum("")
+ * cdef indirect_contiguous = Enum("")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 292, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_XGOTREF(indirect_contiguous);
+  __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "View.MemoryView":316
+ * 
+ * DEF THREAD_LOCKS_PREALLOCATED = 8
+ * cdef int __pyx_memoryview_thread_locks_used = 0             # <<<<<<<<<<<<<<
+ * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [
+ *     PyThread_allocate_lock(),
+ */
+  __pyx_memoryview_thread_locks_used = 0;
+
+  /* "View.MemoryView":317
+ * DEF THREAD_LOCKS_PREALLOCATED = 8
+ * cdef int __pyx_memoryview_thread_locks_used = 0
+ * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [             # <<<<<<<<<<<<<<
+ *     PyThread_allocate_lock(),
+ *     PyThread_allocate_lock(),
+ */
+  __pyx_t_4[0] = PyThread_allocate_lock();
+  __pyx_t_4[1] = PyThread_allocate_lock();
+  __pyx_t_4[2] = PyThread_allocate_lock();
+  __pyx_t_4[3] = PyThread_allocate_lock();
+  __pyx_t_4[4] = PyThread_allocate_lock();
+  __pyx_t_4[5] = PyThread_allocate_lock();
+  __pyx_t_4[6] = PyThread_allocate_lock();
+  __pyx_t_4[7] = PyThread_allocate_lock();
+  memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_4, sizeof(__pyx_memoryview_thread_locks[0]) * (8));
+
+  /* "View.MemoryView":549
+ *         info.obj = self
+ * 
+ *     __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 549, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(2, 549, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  PyType_Modified(__pyx_memoryview_type);
+
+  /* "View.MemoryView":995
+ *         return self.from_object
+ * 
+ *     __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 995, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(2, 995, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  PyType_Modified(__pyx_memoryviewslice_type);
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_1) < 0) __PYX_ERR(2, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.name = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ */
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  if (__pyx_m) {
+    if (__pyx_d) {
+      __Pyx_AddTraceback("init prange_saliency_mbd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    Py_CLEAR(__pyx_m);
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init prange_saliency_mbd");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  return (__pyx_m != NULL) ? 0 : -1;
+  #elif PY_MAJOR_VERSION >= 3
+  return __pyx_m;
+  #else
+  return;
+  #endif
+}
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule(modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, "RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
+    if (unlikely(!result)) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* None */
+static CYTHON_INLINE long __Pyx_div_long(long a, long b) {
+    long q = a / b;
+    long r = a - q*b;
+    q -= ((r != 0) & ((r ^ b) < 0));
+    return q;
+}
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = func->ob_type->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* MemviewSliceInit */
+static int
+__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview,
+                        int ndim,
+                        __Pyx_memviewslice *memviewslice,
+                        int memview_is_new_reference)
+{
+    __Pyx_RefNannyDeclarations
+    int i, retval=-1;
+    Py_buffer *buf = &memview->view;
+    __Pyx_RefNannySetupContext("init_memviewslice", 0);
+    if (unlikely(memviewslice->memview || memviewslice->data)) {
+        PyErr_SetString(PyExc_ValueError,
+            "memviewslice is already initialized!");
+        goto fail;
+    }
+    if (buf->strides) {
+        for (i = 0; i < ndim; i++) {
+            memviewslice->strides[i] = buf->strides[i];
+        }
+    } else {
+        Py_ssize_t stride = buf->itemsize;
+        for (i = ndim - 1; i >= 0; i--) {
+            memviewslice->strides[i] = stride;
+            stride *= buf->shape[i];
+        }
+    }
+    for (i = 0; i < ndim; i++) {
+        memviewslice->shape[i]   = buf->shape[i];
+        if (buf->suboffsets) {
+            memviewslice->suboffsets[i] = buf->suboffsets[i];
+        } else {
+            memviewslice->suboffsets[i] = -1;
+        }
+    }
+    memviewslice->memview = memview;
+    memviewslice->data = (char *)buf->buf;
+    if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) {
+        Py_INCREF(memview);
+    }
+    retval = 0;
+    goto no_fail;
+fail:
+    memviewslice->memview = 0;
+    memviewslice->data = 0;
+    retval = -1;
+no_fail:
+    __Pyx_RefNannyFinishContext();
+    return retval;
+}
+#ifndef Py_NO_RETURN
+#define Py_NO_RETURN
+#endif
+static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN {
+    va_list vargs;
+    char msg[200];
+#ifdef HAVE_STDARG_PROTOTYPES
+    va_start(vargs, fmt);
+#else
+    va_start(vargs);
+#endif
+    vsnprintf(msg, 200, fmt, vargs);
+    va_end(vargs);
+    Py_FatalError(msg);
+}
+static CYTHON_INLINE int
+__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
+                                   PyThread_type_lock lock)
+{
+    int result;
+    PyThread_acquire_lock(lock, 1);
+    result = (*acquisition_count)++;
+    PyThread_release_lock(lock);
+    return result;
+}
+static CYTHON_INLINE int
+__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
+                                   PyThread_type_lock lock)
+{
+    int result;
+    PyThread_acquire_lock(lock, 1);
+    result = (*acquisition_count)--;
+    PyThread_release_lock(lock);
+    return result;
+}
+static CYTHON_INLINE void
+__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno)
+{
+    int first_time;
+    struct __pyx_memoryview_obj *memview = memslice->memview;
+    if (unlikely(!memview || (PyObject *) memview == Py_None))
+        return;
+    if (unlikely(__pyx_get_slice_count(memview) < 0))
+        __pyx_fatalerror("Acquisition count is %d (line %d)",
+                         __pyx_get_slice_count(memview), lineno);
+    first_time = __pyx_add_acquisition_count(memview) == 0;
+    if (unlikely(first_time)) {
+        if (have_gil) {
+            Py_INCREF((PyObject *) memview);
+        } else {
+            PyGILState_STATE _gilstate = PyGILState_Ensure();
+            Py_INCREF((PyObject *) memview);
+            PyGILState_Release(_gilstate);
+        }
+    }
+}
+static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice,
+                                             int have_gil, int lineno) {
+    int last_time;
+    struct __pyx_memoryview_obj *memview = memslice->memview;
+    if (unlikely(!memview || (PyObject *) memview == Py_None)) {
+        memslice->memview = NULL;
+        return;
+    }
+    if (unlikely(__pyx_get_slice_count(memview) <= 0))
+        __pyx_fatalerror("Acquisition count is %d (line %d)",
+                         __pyx_get_slice_count(memview), lineno);
+    last_time = __pyx_sub_acquisition_count(memview) == 1;
+    memslice->data = NULL;
+    if (unlikely(last_time)) {
+        if (have_gil) {
+            Py_CLEAR(memslice->memview);
+        } else {
+            PyGILState_STATE _gilstate = PyGILState_Ensure();
+            Py_CLEAR(memslice->memview);
+            PyGILState_Release(_gilstate);
+        }
+    } else {
+        memslice->memview = NULL;
+    }
+}
+
+/* IsLittleEndian */
+static CYTHON_INLINE int __Pyx_Is_Little_Endian(void)
+{
+  union {
+    uint32_t u32;
+    uint8_t u8[4];
+  } S;
+  S.u32 = 0x01020304;
+  return S.u8[0] == 4;
+}
+
+/* BufferFormatCheck */
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type) {
+  stack[0].field = &ctx->root;
+  stack[0].parent_offset = 0;
+  ctx->root.type = type;
+  ctx->root.name = "buffer dtype";
+  ctx->root.offset = 0;
+  ctx->head = stack;
+  ctx->head->field = &ctx->root;
+  ctx->fmt_offset = 0;
+  ctx->head->parent_offset = 0;
+  ctx->new_packmode = '@';
+  ctx->enc_packmode = '@';
+  ctx->new_count = 1;
+  ctx->enc_count = 0;
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  ctx->is_valid_array = 0;
+  ctx->struct_alignment = 0;
+  while (type->typegroup == 'S') {
+    ++ctx->head;
+    ctx->head->field = type->fields;
+    ctx->head->parent_offset = 0;
+    type = type->fields->type;
+  }
+}
+static int __Pyx_BufFmt_ParseNumber(const char** ts) {
+    int count;
+    const char* t = *ts;
+    if (*t < '0' || *t > '9') {
+      return -1;
+    } else {
+        count = *t++ - '0';
+        while (*t >= '0' && *t <= '9') {
+            count *= 10;
+            count += *t++ - '0';
+        }
+    }
+    *ts = t;
+    return count;
+}
+static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
+    int number = __Pyx_BufFmt_ParseNumber(ts);
+    if (number == -1)
+        PyErr_Format(PyExc_ValueError,\
+                     "Does not understand character buffer dtype format string ('%c')", **ts);
+    return number;
+}
+static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
+  PyErr_Format(PyExc_ValueError,
+               "Unexpected format string character: '%c'", ch);
+}
+static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
+  switch (ch) {
+    case '?': return "'bool'";
+    case 'c': return "'char'";
+    case 'b': return "'signed char'";
+    case 'B': return "'unsigned char'";
+    case 'h': return "'short'";
+    case 'H': return "'unsigned short'";
+    case 'i': return "'int'";
+    case 'I': return "'unsigned int'";
+    case 'l': return "'long'";
+    case 'L': return "'unsigned long'";
+    case 'q': return "'long long'";
+    case 'Q': return "'unsigned long long'";
+    case 'f': return (is_complex ? "'complex float'" : "'float'");
+    case 'd': return (is_complex ? "'complex double'" : "'double'");
+    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
+    case 'T': return "a struct";
+    case 'O': return "Python object";
+    case 'P': return "a pointer";
+    case 's': case 'p': return "a string";
+    case 0: return "end";
+    default: return "unparseable format string";
+  }
+}
+static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return 2;
+    case 'i': case 'I': case 'l': case 'L': return 4;
+    case 'q': case 'Q': return 8;
+    case 'f': return (is_complex ? 8 : 4);
+    case 'd': return (is_complex ? 16 : 8);
+    case 'g': {
+      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
+      return 0;
+    }
+    case 'O': case 'P': return sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(short);
+    case 'i': case 'I': return sizeof(int);
+    case 'l': case 'L': return sizeof(long);
+    #ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
+    #endif
+    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
+    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
+    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
+    case 'O': case 'P': return sizeof(void*);
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+typedef struct { char c; short x; } __Pyx_st_short;
+typedef struct { char c; int x; } __Pyx_st_int;
+typedef struct { char c; long x; } __Pyx_st_long;
+typedef struct { char c; float x; } __Pyx_st_float;
+typedef struct { char c; double x; } __Pyx_st_double;
+typedef struct { char c; long double x; } __Pyx_st_longdouble;
+typedef struct { char c; void *x; } __Pyx_st_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+/* These are for computing the padding at the end of the struct to align
+   on the first member of the struct. This will probably the same as above,
+   but we don't have any guarantees.
+ */
+typedef struct { short x; char c; } __Pyx_pad_short;
+typedef struct { int x; char c; } __Pyx_pad_int;
+typedef struct { long x; char c; } __Pyx_pad_long;
+typedef struct { float x; char c; } __Pyx_pad_float;
+typedef struct { double x; char c; } __Pyx_pad_double;
+typedef struct { long double x; char c; } __Pyx_pad_longdouble;
+typedef struct { void *x; char c; } __Pyx_pad_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
+  switch (ch) {
+    case 'c':
+        return 'H';
+    case 'b': case 'h': case 'i':
+    case 'l': case 'q': case 's': case 'p':
+        return 'I';
+    case '?': case 'B': case 'H': case 'I': case 'L': case 'Q':
+        return 'U';
+    case 'f': case 'd': case 'g':
+        return (is_complex ? 'C' : 'R');
+    case 'O':
+        return 'O';
+    case 'P':
+        return 'P';
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
+  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
+    const char* expected;
+    const char* quote;
+    if (ctx->head == NULL) {
+      expected = "end";
+      quote = "";
+    } else {
+      expected = ctx->head->field->type->name;
+      quote = "'";
+    }
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected %s%s%s but got %s",
+                 quote, expected, quote,
+                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
+  } else {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_StructField* parent = (ctx->head - 1)->field;
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
+                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
+                 parent->type->name, field->name);
+  }
+}
+static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
+  char group;
+  size_t size, offset, arraysize = 1;
+  if (ctx->enc_type == 0) return 0;
+  if (ctx->head->field->type->arraysize[0]) {
+    int i, ndim = 0;
+    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
+        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
+        ndim = 1;
+        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
+            PyErr_Format(PyExc_ValueError,
+                         "Expected a dimension of size %zu, got %zu",
+                         ctx->head->field->type->arraysize[0], ctx->enc_count);
+            return -1;
+        }
+    }
+    if (!ctx->is_valid_array) {
+      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
+                   ctx->head->field->type->ndim, ndim);
+      return -1;
+    }
+    for (i = 0; i < ctx->head->field->type->ndim; i++) {
+      arraysize *= ctx->head->field->type->arraysize[i];
+    }
+    ctx->is_valid_array = 0;
+    ctx->enc_count = 1;
+  }
+  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
+  do {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_TypeInfo* type = field->type;
+    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
+      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
+    } else {
+      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
+    }
+    if (ctx->enc_packmode == '@') {
+      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
+      size_t align_mod_offset;
+      if (align_at == 0) return -1;
+      align_mod_offset = ctx->fmt_offset % align_at;
+      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
+      if (ctx->struct_alignment == 0)
+          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
+                                                                 ctx->is_complex);
+    }
+    if (type->size != size || type->typegroup != group) {
+      if (type->typegroup == 'C' && type->fields != NULL) {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        ++ctx->head;
+        ctx->head->field = type->fields;
+        ctx->head->parent_offset = parent_offset;
+        continue;
+      }
+      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
+      } else {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+      }
+    }
+    offset = ctx->head->parent_offset + field->offset;
+    if (ctx->fmt_offset != offset) {
+      PyErr_Format(PyExc_ValueError,
+                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
+                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
+      return -1;
+    }
+    ctx->fmt_offset += size;
+    if (arraysize)
+      ctx->fmt_offset += (arraysize - 1) * size;
+    --ctx->enc_count;
+    while (1) {
+      if (field == &ctx->root) {
+        ctx->head = NULL;
+        if (ctx->enc_count != 0) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+        }
+        break;
+      }
+      ctx->head->field = ++field;
+      if (field->type == NULL) {
+        --ctx->head;
+        field = ctx->head->field;
+        continue;
+      } else if (field->type->typegroup == 'S') {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        if (field->type->fields->type == NULL) continue;
+        field = field->type->fields;
+        ++ctx->head;
+        ctx->head->field = field;
+        ctx->head->parent_offset = parent_offset;
+        break;
+      } else {
+        break;
+      }
+    }
+  } while (ctx->enc_count);
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  return 0;
+}
+static PyObject *
+__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
+{
+    const char *ts = *tsp;
+    int i = 0, number, ndim;
+    ++ts;
+    if (ctx->new_count != 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Cannot handle repeated arrays in format string");
+        return NULL;
+    }
+    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+    ndim = ctx->head->field->type->ndim;
+    while (*ts && *ts != ')') {
+        switch (*ts) {
+            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
+            default:  break;
+        }
+        number = __Pyx_BufFmt_ExpectNumber(&ts);
+        if (number == -1) return NULL;
+        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
+            return PyErr_Format(PyExc_ValueError,
+                        "Expected a dimension of size %zu, got %d",
+                        ctx->head->field->type->arraysize[i], number);
+        if (*ts != ',' && *ts != ')')
+            return PyErr_Format(PyExc_ValueError,
+                                "Expected a comma in format string, got '%c'", *ts);
+        if (*ts == ',') ts++;
+        i++;
+    }
+    if (i != ndim)
+        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
+                            ctx->head->field->type->ndim, i);
+    if (!*ts) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Unexpected end of format string, expected ')'");
+        return NULL;
+    }
+    ctx->is_valid_array = 1;
+    ctx->new_count = 1;
+    *tsp = ++ts;
+    return Py_None;
+}
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
+  int got_Z = 0;
+  while (1) {
+    switch(*ts) {
+      case 0:
+        if (ctx->enc_type != 0 && ctx->head == NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        if (ctx->head != NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        return ts;
+      case ' ':
+      case '\r':
+      case '\n':
+        ++ts;
+        break;
+      case '<':
+        if (!__Pyx_Is_Little_Endian()) {
+          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '>':
+      case '!':
+        if (__Pyx_Is_Little_Endian()) {
+          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '=':
+      case '@':
+      case '^':
+        ctx->new_packmode = *ts++;
+        break;
+      case 'T':
+        {
+          const char* ts_after_sub;
+          size_t i, struct_count = ctx->new_count;
+          size_t struct_alignment = ctx->struct_alignment;
+          ctx->new_count = 1;
+          ++ts;
+          if (*ts != '{') {
+            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
+            return NULL;
+          }
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          ctx->enc_count = 0;
+          ctx->struct_alignment = 0;
+          ++ts;
+          ts_after_sub = ts;
+          for (i = 0; i != struct_count; ++i) {
+            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
+            if (!ts_after_sub) return NULL;
+          }
+          ts = ts_after_sub;
+          if (struct_alignment) ctx->struct_alignment = struct_alignment;
+        }
+        break;
+      case '}':
+        {
+          size_t alignment = ctx->struct_alignment;
+          ++ts;
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          if (alignment && ctx->fmt_offset % alignment) {
+            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
+          }
+        }
+        return ts;
+      case 'x':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->fmt_offset += ctx->new_count;
+        ctx->new_count = 1;
+        ctx->enc_count = 0;
+        ctx->enc_type = 0;
+        ctx->enc_packmode = ctx->new_packmode;
+        ++ts;
+        break;
+      case 'Z':
+        got_Z = 1;
+        ++ts;
+        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
+          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
+          return NULL;
+        }
+        CYTHON_FALLTHROUGH;
+      case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
+      case 'l': case 'L': case 'q': case 'Q':
+      case 'f': case 'd': case 'g':
+      case 'O': case 'p':
+        if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) &&
+            (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) {
+          ctx->enc_count += ctx->new_count;
+          ctx->new_count = 1;
+          got_Z = 0;
+          ++ts;
+          break;
+        }
+        CYTHON_FALLTHROUGH;
+      case 's':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->enc_count = ctx->new_count;
+        ctx->enc_packmode = ctx->new_packmode;
+        ctx->enc_type = *ts;
+        ctx->is_complex = got_Z;
+        ++ts;
+        ctx->new_count = 1;
+        got_Z = 0;
+        break;
+      case ':':
+        ++ts;
+        while(*ts != ':') ++ts;
+        ++ts;
+        break;
+      case '(':
+        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
+        break;
+      default:
+        {
+          int number = __Pyx_BufFmt_ExpectNumber(&ts);
+          if (number == -1) return NULL;
+          ctx->new_count = (size_t)number;
+        }
+    }
+  }
+}
+
+/* BufferGetAndValidate */
+  static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
+  if (unlikely(info->buf == NULL)) return;
+  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
+  __Pyx_ReleaseBuffer(info);
+}
+static void __Pyx_ZeroBuffer(Py_buffer* buf) {
+  buf->buf = NULL;
+  buf->obj = NULL;
+  buf->strides = __Pyx_zeros;
+  buf->shape = __Pyx_zeros;
+  buf->suboffsets = __Pyx_minusones;
+}
+static int __Pyx__GetBufferAndValidate(
+        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
+        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
+{
+  buf->buf = NULL;
+  if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) {
+    __Pyx_ZeroBuffer(buf);
+    return -1;
+  }
+  if (unlikely(buf->ndim != nd)) {
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer has wrong number of dimensions (expected %d, got %d)",
+                 nd, buf->ndim);
+    goto fail;
+  }
+  if (!cast) {
+    __Pyx_BufFmt_Context ctx;
+    __Pyx_BufFmt_Init(&ctx, stack, dtype);
+    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
+  }
+  if (unlikely((size_t)buf->itemsize != dtype->size)) {
+    PyErr_Format(PyExc_ValueError,
+      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
+      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
+      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
+    goto fail;
+  }
+  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
+  return 0;
+fail:;
+  __Pyx_SafeReleaseBuffer(buf);
+  return -1;
+}
+
+/* GetItemInt */
+  static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
+    PyObject *r;
+    if (!j) return NULL;
+    r = PyObject_GetItem(o, j);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    Py_ssize_t wrapped_i = i;
+    if (wraparound & unlikely(i < 0)) {
+        wrapped_i += PyList_GET_SIZE(o);
+    }
+    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
+        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    Py_ssize_t wrapped_i = i;
+    if (wraparound & unlikely(i < 0)) {
+        wrapped_i += PyTuple_GET_SIZE(o);
+    }
+    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
+        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
+                                                     CYTHON_NCP_UNUSED int wraparound,
+                                                     CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
+        if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
+            PyObject *r = PyList_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    }
+    else if (PyTuple_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
+            PyObject *r = PyTuple_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    } else {
+        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
+        if (likely(m && m->sq_item)) {
+            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
+                Py_ssize_t l = m->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return NULL;
+                    PyErr_Clear();
+                }
+            }
+            return m->sq_item(o, i);
+        }
+    }
+#else
+    if (is_list || PySequence_Check(o)) {
+        return PySequence_GetItem(o, i);
+    }
+#endif
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+}
+
+/* ObjectGetItem */
+  #if CYTHON_USE_TYPE_SLOTS
+static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) {
+    PyObject *runerr;
+    Py_ssize_t key_value;
+    PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence;
+    if (unlikely(!(m && m->sq_item))) {
+        PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name);
+        return NULL;
+    }
+    key_value = __Pyx_PyIndex_AsSsize_t(index);
+    if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
+        return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
+    }
+    if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
+        PyErr_Clear();
+        PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name);
+    }
+    return NULL;
+}
+static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) {
+    PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping;
+    if (likely(m && m->mp_subscript)) {
+        return m->mp_subscript(obj, key);
+    }
+    return __Pyx_PyObject_GetIndex(obj, key);
+}
+#endif
+
+/* PyDictVersioning */
+  #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
+    PyObject **dictptr = NULL;
+    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
+    if (offset) {
+#if CYTHON_COMPILING_IN_CPYTHON
+        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+#else
+        dictptr = _PyObject_GetDictPtr(obj);
+#endif
+    }
+    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+}
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
+        return 0;
+    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+}
+#endif
+
+/* GetModuleGlobalName */
+  #if CYTHON_USE_DICT_VERSIONS
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
+#else
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
+#endif
+{
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+    result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    } else if (unlikely(PyErr_Occurred())) {
+        return NULL;
+    }
+#else
+    result = PyDict_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+#endif
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+    PyErr_Clear();
+#endif
+    return __Pyx_GetBuiltinName(name);
+}
+
+/* PyFunctionFastCall */
+  #if CYTHON_FAST_PYCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+        return NULL;
+    }
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif
+#endif
+
+/* PyCFunctionFastCall */
+  #if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
+    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
+    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
+    PyObject *self = PyCFunction_GET_SELF(func);
+    int flags = PyCFunction_GET_FLAGS(func);
+    assert(PyCFunction_Check(func));
+    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
+    assert(nargs >= 0);
+    assert(nargs == 0 || args != NULL);
+    /* _PyCFunction_FastCallDict() must not be called with an exception set,
+       because it may clear it (directly or indirectly) and so the
+       caller loses its exception */
+    assert(!PyErr_Occurred());
+    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
+        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
+    } else {
+        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
+    }
+}
+#endif
+
+/* ExtTypeTest */
+  static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (likely(__Pyx_TypeCheck(obj, type)))
+        return 1;
+    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
+                 Py_TYPE(obj)->tp_name, type->tp_name);
+    return 0;
+}
+
+/* None */
+  static CYTHON_INLINE long __Pyx_mod_long(long a, long b) {
+    long r = a % b;
+    r += ((r != 0) & ((r ^ b) < 0)) * b;
+    return r;
+}
+
+/* PyErrFetchRestore */
+  #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+}
+#endif
+
+/* RaiseTooManyValuesToUnpack */
+  static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+  static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* IterFinish */
+  static CYTHON_INLINE int __Pyx_IterFinish(void) {
+#if CYTHON_FAST_THREAD_STATE
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject* exc_type = tstate->curexc_type;
+    if (unlikely(exc_type)) {
+        if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) {
+            PyObject *exc_value, *exc_tb;
+            exc_value = tstate->curexc_value;
+            exc_tb = tstate->curexc_traceback;
+            tstate->curexc_type = 0;
+            tstate->curexc_value = 0;
+            tstate->curexc_traceback = 0;
+            Py_DECREF(exc_type);
+            Py_XDECREF(exc_value);
+            Py_XDECREF(exc_tb);
+            return 0;
+        } else {
+            return -1;
+        }
+    }
+    return 0;
+#else
+    if (unlikely(PyErr_Occurred())) {
+        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
+            PyErr_Clear();
+            return 0;
+        } else {
+            return -1;
+        }
+    }
+    return 0;
+#endif
+}
+
+/* UnpackItemEndCheck */
+  static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
+    if (unlikely(retval)) {
+        Py_DECREF(retval);
+        __Pyx_RaiseTooManyValuesError(expected);
+        return -1;
+    } else {
+        return __Pyx_IterFinish();
+    }
+    return 0;
+}
+
+/* PyObjectCall2Args */
+  static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
+    PyObject *args, *result = NULL;
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(function)) {
+        PyObject *args[2] = {arg1, arg2};
+        return __Pyx_PyFunction_FastCall(function, args, 2);
+    }
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(function)) {
+        PyObject *args[2] = {arg1, arg2};
+        return __Pyx_PyCFunction_FastCall(function, args, 2);
+    }
+    #endif
+    args = PyTuple_New(2);
+    if (unlikely(!args)) goto done;
+    Py_INCREF(arg1);
+    PyTuple_SET_ITEM(args, 0, arg1);
+    Py_INCREF(arg2);
+    PyTuple_SET_ITEM(args, 1, arg2);
+    Py_INCREF(function);
+    result = __Pyx_PyObject_Call(function, args, NULL);
+    Py_DECREF(args);
+    Py_DECREF(function);
+done:
+    return result;
+}
+
+/* PyObjectCallMethO */
+  #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = PyCFunction_GET_FUNCTION(func);
+    self = PyCFunction_GET_SELF(func);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallOneArg */
+  #if CYTHON_COMPILING_IN_CPYTHON
+static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *result;
+    PyObject *args = PyTuple_New(1);
+    if (unlikely(!args)) return NULL;
+    Py_INCREF(arg);
+    PyTuple_SET_ITEM(args, 0, arg);
+    result = __Pyx_PyObject_Call(func, args, NULL);
+    Py_DECREF(args);
+    return result;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+#if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCall(func, &arg, 1);
+    }
+#endif
+    if (likely(PyCFunction_Check(func))) {
+        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
+            return __Pyx_PyObject_CallMethO(func, arg);
+#if CYTHON_FAST_PYCCALL
+        } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {
+            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+#endif
+        }
+    }
+    return __Pyx__PyObject_CallOneArg(func, arg);
+}
+#else
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *result;
+    PyObject *args = PyTuple_Pack(1, arg);
+    if (unlikely(!args)) return NULL;
+    result = __Pyx_PyObject_Call(func, args, NULL);
+    Py_DECREF(args);
+    return result;
+}
+#endif
+
+/* PyFloatBinop */
+  #if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyFloat_SubtractObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) {
+    const double b = floatval;
+    double a, result;
+    (void)inplace;
+    (void)zerodivision_check;
+    if (likely(PyFloat_CheckExact(op1))) {
+        a = PyFloat_AS_DOUBLE(op1);
+        
+    } else
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        a = (double) PyInt_AS_LONG(op1);
+        
+    } else
+    #endif
+    if (likely(PyLong_CheckExact(op1))) {
+        #if CYTHON_USE_PYLONG_INTERNALS
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        switch (size) {
+            case  0: a = 0.0; break;
+            case -1: a = -(double) digits[0]; break;
+            case  1: a = (double) digits[0]; break;
+            case -2:
+            case 2:
+                if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) {
+                    a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                    if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                        if (size == -2)
+                            a = -a;
+                        break;
+                    }
+                }
+                CYTHON_FALLTHROUGH;
+            case -3:
+            case 3:
+                if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) {
+                    a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                    if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                        if (size == -3)
+                            a = -a;
+                        break;
+                    }
+                }
+                CYTHON_FALLTHROUGH;
+            case -4:
+            case 4:
+                if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) {
+                    a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                    if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                        if (size == -4)
+                            a = -a;
+                        break;
+                    }
+                }
+                CYTHON_FALLTHROUGH;
+            default:
+        #else
+        {
+        #endif
+            a = PyLong_AsDouble(op1);
+            if (unlikely(a == -1.0 && PyErr_Occurred())) return NULL;
+            
+        }
+    } else {
+        return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2);
+    }
+        
+        PyFPE_START_PROTECT("subtract", return NULL)
+        result = a - b;
+        PyFPE_END_PROTECT(result)
+        return PyFloat_FromDouble(result);
+}
+#endif
+
+/* PyIntFromDouble */
+    #if PY_MAJOR_VERSION < 3
+static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value) {
+    if (value >= (double)LONG_MIN && value <= (double)LONG_MAX) {
+        return PyInt_FromLong((long)value);
+    }
+    return PyLong_FromDouble(value);
+}
+#endif
+
+/* SetItemInt */
+    static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
+    int r;
+    if (!j) return -1;
+    r = PyObject_SetItem(o, j, v);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list,
+                                               CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) {
+            PyObject* old = PyList_GET_ITEM(o, n);
+            Py_INCREF(v);
+            PyList_SET_ITEM(o, n, v);
+            Py_DECREF(old);
+            return 1;
+        }
+    } else {
+        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
+        if (likely(m && m->sq_ass_item)) {
+            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
+                Py_ssize_t l = m->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return -1;
+                    PyErr_Clear();
+                }
+            }
+            return m->sq_ass_item(o, i, v);
+        }
+    }
+#else
+#if CYTHON_COMPILING_IN_PYPY
+    if (is_list || (PySequence_Check(o) && !PyDict_Check(o)))
+#else
+    if (is_list || PySequence_Check(o))
+#endif
+    {
+        return PySequence_SetItem(o, i, v);
+    }
+#endif
+    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
+}
+
+/* PyIntBinop */
+    #if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) {
+    (void)inplace;
+    (void)zerodivision_check;
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long x;
+        long a = PyInt_AS_LONG(op1);
+            x = (long)((unsigned long)a - b);
+            if (likely((x^a) >= 0 || (x^~b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_subtract(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            a = likely(size) ? digits[0] : 0;
+            if (size == -1) a = -a;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2);
+            }
+        }
+                x = a - b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla - llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+            double result;
+            PyFPE_START_PROTECT("subtract", return NULL)
+            result = ((double)a) - (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2);
+}
+#endif
+
+/* None */
+    static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) {
+    Py_ssize_t q = a / b;
+    Py_ssize_t r = a - q*b;
+    q -= ((r != 0) & ((r ^ b) < 0));
+    return q;
+}
+
+/* BufferFallbackError */
+    static void __Pyx_RaiseBufferFallbackError(void) {
+  PyErr_SetString(PyExc_ValueError,
+     "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!");
+}
+
+/* None */
+    static CYTHON_INLINE Py_ssize_t __Pyx_mod_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) {
+    Py_ssize_t r = a % b;
+    r += ((r != 0) & ((r ^ b) < 0)) * b;
+    return r;
+}
+
+/* PyIntBinop */
+    #if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_SubtractCObj(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) {
+    (void)inplace;
+    (void)zerodivision_check;
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op2))) {
+        const long a = intval;
+        long x;
+        long b = PyInt_AS_LONG(op2);
+            x = (long)((unsigned long)a - b);
+            if (likely((x^a) >= 0 || (x^~b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_subtract(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op2))) {
+        const long a = intval;
+        long b, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG lla = intval;
+        PY_LONG_LONG llb, llx;
+#endif
+        const digit* digits = ((PyLongObject*)op2)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op2);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            b = likely(size) ? digits[0] : 0;
+            if (size == -1) b = -b;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        b = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        llb = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        b = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        llb = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        b = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        llb = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        b = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        llb = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        b = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        llb = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        b = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        llb = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2);
+            }
+        }
+                x = a - b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla - llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op2)) {
+        const long a = intval;
+        double b = PyFloat_AS_DOUBLE(op2);
+            double result;
+            PyFPE_START_PROTECT("subtract", return NULL)
+            result = ((double)a) - (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2);
+}
+#endif
+
+/* RaiseDoubleKeywords */
+    static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+    static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    while (PyDict_Next(kwds, &pos, &key, &value)) {
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+            continue;
+        }
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (**name == key) ? 0 :
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key);
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+    #if PY_MAJOR_VERSION < 3
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    return -1;
+}
+
+/* RaiseArgTupleInvalid */
+    static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* ArgTypeTest */
+    static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
+{
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    else if (exact) {
+        #if PY_MAJOR_VERSION == 2
+        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    }
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
+        name, type->tp_name, Py_TYPE(obj)->tp_name);
+    return 0;
+}
+
+/* RaiseException */
+    #if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
+                        CYTHON_UNUSED PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+    if (cause) {
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+#if CYTHON_COMPILING_IN_PYPY
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#else
+        PyThreadState *tstate = __Pyx_PyThreadState_Current;
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+/* DictGetItem */
+    #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            if (unlikely(PyTuple_Check(key))) {
+                PyObject* args = PyTuple_Pack(1, key);
+                if (likely(args)) {
+                    PyErr_SetObject(PyExc_KeyError, args);
+                    Py_DECREF(args);
+                }
+            } else {
+                PyErr_SetObject(PyExc_KeyError, key);
+            }
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#endif
+
+/* RaiseNoneIterError */
+    static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* GetTopmostException */
+    #if CYTHON_USE_EXC_INFO_STACK
+static _PyErr_StackItem *
+__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
+{
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
+           exc_info->previous_item != NULL)
+    {
+        exc_info = exc_info->previous_item;
+    }
+    return exc_info;
+}
+#endif
+
+/* SaveResetException */
+    #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    *type = exc_info->exc_type;
+    *value = exc_info->exc_value;
+    *tb = exc_info->exc_traceback;
+    #else
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    #endif
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = type;
+    exc_info->exc_value = value;
+    exc_info->exc_traceback = tb;
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+#endif
+
+/* PyErrExceptionMatches */
+    #if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; icurexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+    if (unlikely(PyTuple_Check(err)))
+        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+}
+#endif
+
+/* GetException */
+    #if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
+#endif
+{
+    PyObject *local_type, *local_value, *local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    #if CYTHON_USE_EXC_INFO_STACK
+    {
+        _PyErr_StackItem *exc_info = tstate->exc_info;
+        tmp_type = exc_info->exc_type;
+        tmp_value = exc_info->exc_value;
+        tmp_tb = exc_info->exc_traceback;
+        exc_info->exc_type = local_type;
+        exc_info->exc_value = local_value;
+        exc_info->exc_traceback = local_tb;
+    }
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/* FetchCommonType */
+    static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* fake_module;
+    PyTypeObject* cached_type = NULL;
+    fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
+    if (!fake_module) return NULL;
+    Py_INCREF(fake_module);
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
+    if (cached_type) {
+        if (!PyType_Check((PyObject*)cached_type)) {
+            PyErr_Format(PyExc_TypeError,
+                "Shared Cython type %.200s is not a type object",
+                type->tp_name);
+            goto bad;
+        }
+        if (cached_type->tp_basicsize != type->tp_basicsize) {
+            PyErr_Format(PyExc_TypeError,
+                "Shared Cython type %.200s has the wrong size, try recompiling",
+                type->tp_name);
+            goto bad;
+        }
+    } else {
+        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+        PyErr_Clear();
+        if (PyType_Ready(type) < 0) goto bad;
+        if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
+            goto bad;
+        Py_INCREF(type);
+        cached_type = type;
+    }
+done:
+    Py_DECREF(fake_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+
+/* CythonFunctionShared */
+    #include 
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
+{
+    if (unlikely(op->func_doc == NULL)) {
+        if (op->func.m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+{
+    PyObject *tmp = op->func_doc;
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    op->func_doc = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+{
+    if (unlikely(op->func_name == NULL)) {
+#if PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+{
+    PyObject *tmp;
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    tmp = op->func_name;
+    Py_INCREF(value);
+    op->func_name = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+{
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+{
+    PyObject *tmp;
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    tmp = op->func_qualname;
+    Py_INCREF(value);
+    op->func_qualname = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure)
+{
+    PyObject *self;
+    self = m->func_closure;
+    if (self == NULL)
+        self = Py_None;
+    Py_INCREF(self);
+    return self;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+{
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+{
+    PyObject *tmp;
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    tmp = op->func_dict;
+    Py_INCREF(value);
+    op->func_dict = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+{
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+{
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
+    PyObject* tmp;
+    if (!value) {
+        value = Py_None;
+    } else if (value != Py_None && !PyTuple_Check(value)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    Py_INCREF(value);
+    tmp = op->defaults_tuple;
+    op->defaults_tuple = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+    PyObject* result = op->defaults_tuple;
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
+    PyObject* tmp;
+    if (!value) {
+        value = Py_None;
+    } else if (value != Py_None && !PyDict_Check(value)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    Py_INCREF(value);
+    tmp = op->defaults_kwdict;
+    op->defaults_kwdict = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+    PyObject* result = op->defaults_kwdict;
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
+    PyObject* tmp;
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (!PyDict_Check(value)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    tmp = op->func_annotations;
+    op->func_annotations = value;
+    Py_XDECREF(tmp);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+    PyObject* result = op->func_annotations;
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0},
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromString(m->func.m_ml->ml_name);
+#else
+    return PyString_FromString(m->func.m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    if (unlikely(op == NULL))
+        return NULL;
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+    op->func.m_ml = ml;
+    op->func.m_self = (PyObject *) op;
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+    Py_XINCREF(module);
+    op->func.m_module = module;
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+    op->func_classobj = NULL;
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+    Py_CLEAR(m->func.m_module);
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+    Py_CLEAR(m->func_classobj);
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    PyObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+    Py_VISIT(m->func.m_module);
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+    Py_VISIT(m->func_classobj);
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
+{
+#if PY_MAJOR_VERSION < 3
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
+        Py_INCREF(func);
+        return func;
+    }
+    if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) {
+        if (type == NULL)
+            type = (PyObject *)(Py_TYPE(obj));
+        return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type)));
+    }
+    if (obj == Py_None)
+        obj = NULL;
+#endif
+    return __Pyx_PyMethod_New(func, obj, type);
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    Py_ssize_t size;
+    switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+            size = PyTuple_GET_SIZE(arg);
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+            size = PyTuple_GET_SIZE(arg);
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags in "
+                        "__Pyx_CyFunction_Call. METH_OLDARGS is no "
+                        "longer supported!");
+        return NULL;
+    }
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw);
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+        argc = PyTuple_GET_SIZE(args);
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+    0,
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_CyFunction_descr_get,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+    0,
+#endif
+};
+static int __pyx_CyFunction_init(void) {
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+    static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
+}
+
+/* BytesEquals */
+    static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+    static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* GetAttr */
+    static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
+#if CYTHON_USE_TYPE_SLOTS
+#if PY_MAJOR_VERSION >= 3
+    if (likely(PyUnicode_Check(n)))
+#else
+    if (likely(PyString_Check(n)))
+#endif
+        return __Pyx_PyObject_GetAttrStr(o, n);
+#endif
+    return PyObject_GetAttr(o, n);
+}
+
+/* decode_c_string */
+    static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
+         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    Py_ssize_t length;
+    if (unlikely((start < 0) | (stop < 0))) {
+        size_t slen = strlen(cstring);
+        if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "c-string too long to convert to Python");
+            return NULL;
+        }
+        length = (Py_ssize_t) slen;
+        if (start < 0) {
+            start += length;
+            if (start < 0)
+                start = 0;
+        }
+        if (stop < 0)
+            stop += length;
+    }
+    if (unlikely(stop <= start))
+        return __Pyx_NewRef(__pyx_empty_unicode);
+    length = stop - start;
+    cstring += start;
+    if (decode_func) {
+        return decode_func(cstring, length, errors);
+    } else {
+        return PyUnicode_Decode(cstring, length, encoding, errors);
+    }
+}
+
+/* GetAttr3 */
+    static PyObject *__Pyx_GetAttr3Default(PyObject *d) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        return NULL;
+    __Pyx_PyErr_Clear();
+    Py_INCREF(d);
+    return d;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
+    PyObject *r = __Pyx_GetAttr(o, n);
+    return (likely(r)) ? r : __Pyx_GetAttr3Default(d);
+}
+
+/* SwapException */
+    #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = *type;
+    exc_info->exc_value = *value;
+    exc_info->exc_traceback = *tb;
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = *type;
+    tstate->exc_value = *value;
+    tstate->exc_traceback = *tb;
+    #endif
+    *type = tmp_type;
+    *value = tmp_value;
+    *tb = tmp_tb;
+}
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
+    PyErr_SetExcInfo(*type, *value, *tb);
+    *type = tmp_type;
+    *value = tmp_value;
+    *tb = tmp_tb;
+}
+#endif
+
+/* Import */
+    static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *empty_list = 0;
+    PyObject *module = 0;
+    PyObject *global_dict = 0;
+    PyObject *empty_dict = 0;
+    PyObject *list;
+    #if PY_MAJOR_VERSION < 3
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (!py_import)
+        goto bad;
+    #endif
+    if (from_list)
+        list = from_list;
+    else {
+        empty_list = PyList_New(0);
+        if (!empty_list)
+            goto bad;
+        list = empty_list;
+    }
+    global_dict = PyModule_GetDict(__pyx_m);
+    if (!global_dict)
+        goto bad;
+    empty_dict = PyDict_New();
+    if (!empty_dict)
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
+                module = PyImport_ImportModuleLevelObject(
+                    name, global_dict, empty_dict, list, 1);
+                if (!module) {
+                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                        goto bad;
+                    PyErr_Clear();
+                }
+            }
+            level = 0;
+        }
+        #endif
+        if (!module) {
+            #if PY_MAJOR_VERSION < 3
+            PyObject *py_level = PyInt_FromLong(level);
+            if (!py_level)
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, global_dict, empty_dict, list, level);
+            #endif
+        }
+    }
+bad:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    Py_XDECREF(empty_list);
+    Py_XDECREF(empty_dict);
+    return module;
+}
+
+/* FastTypeChecks */
+    #if CYTHON_COMPILING_IN_CPYTHON
+static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
+    while (a) {
+        a = a->tp_base;
+        if (a == b)
+            return 1;
+    }
+    return b == &PyBaseObject_Type;
+}
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (a == b) return 1;
+    mro = a->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(a, b);
+}
+#if PY_MAJOR_VERSION == 2
+static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
+    PyObject *exception, *value, *tb;
+    int res;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&exception, &value, &tb);
+    res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
+    if (unlikely(res == -1)) {
+        PyErr_WriteUnraisable(err);
+        res = 0;
+    }
+    if (!res) {
+        res = PyObject_IsSubclass(err, exc_type2);
+        if (unlikely(res == -1)) {
+            PyErr_WriteUnraisable(err);
+            res = 0;
+        }
+    }
+    __Pyx_ErrRestore(exception, value, tb);
+    return res;
+}
+#else
+static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
+    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
+    if (!res) {
+        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    }
+    return res;
+}
+#endif
+static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    assert(PyExceptionClass_Check(exc_type));
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i= 0 || (x^b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_add(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            a = likely(size) ? digits[0] : 0;
+            if (size == -1) a = -a;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
+            }
+        }
+                x = a + b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla + llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+            double result;
+            PyFPE_START_PROTECT("add", return NULL)
+            result = ((double)a) + (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+}
+#endif
+
+/* None */
+    static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
+    PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
+}
+
+/* ImportFrom */
+    static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
+    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
+    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Format(PyExc_ImportError,
+        #if PY_MAJOR_VERSION < 3
+            "cannot import name %.230s", PyString_AS_STRING(name));
+        #else
+            "cannot import name %S", name);
+        #endif
+    }
+    return value;
+}
+
+/* HasAttr */
+    static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) {
+    PyObject *r;
+    if (unlikely(!__Pyx_PyBaseString_Check(n))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "hasattr(): attribute name must be string");
+        return -1;
+    }
+    r = __Pyx_GetAttr(o, n);
+    if (unlikely(!r)) {
+        PyErr_Clear();
+        return 0;
+    } else {
+        Py_DECREF(r);
+        return 1;
+    }
+}
+
+/* PyObject_GenericGetAttrNoDict */
+    #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'%.50s' object has no attribute '%U'",
+                 tp->tp_name, attr_name);
+#else
+                 "'%.50s' object has no attribute '%.400s'",
+                 tp->tp_name, PyString_AS_STRING(attr_name));
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
+
+/* PyObject_GenericGetAttr */
+    #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+}
+#endif
+
+/* SetVTable */
+    static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
+#if PY_VERSION_HEX >= 0x02070000
+    PyObject *ob = PyCapsule_New(vtable, 0, 0);
+#else
+    PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
+#endif
+    if (!ob)
+        goto bad;
+    if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0)
+        goto bad;
+    Py_DECREF(ob);
+    return 0;
+bad:
+    Py_XDECREF(ob);
+    return -1;
+}
+
+/* PyObjectGetAttrStrNoError */
+    static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+}
+
+/* SetupReduce */
+    static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
+  }
+  if (unlikely(ret < 0)) {
+      PyErr_Clear();
+      ret = 0;
+  }
+  Py_XDECREF(name_attr);
+  return ret;
+}
+static int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
+#else
+    if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD;
+#endif
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#else
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#endif
+    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
+    if (reduce_ex == object_reduce_ex) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#else
+        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#endif
+        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
+        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
+            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
+            if (!setstate) PyErr_Clear();
+            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
+                }
+            }
+            PyType_Modified((PyTypeObject*)type_obj);
+        }
+    }
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred())
+        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
+}
+
+/* TypeImport */
+    #ifndef __PYX_HAVE_RT_ImportType
+#define __PYX_HAVE_RT_ImportType
+static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+{
+    PyObject *result = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+#ifdef Py_LIMITED_API
+    PyObject *py_basicsize;
+#endif
+    result = PyObject_GetAttrString(module, class_name);
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#ifndef Py_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if ((size_t)basicsize < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        goto bad;
+    }
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* CLineInTraceback */
+    #ifndef CYTHON_CLINE_IN_TRACEBACK
+static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+    PyObject *use_cline;
+    PyObject *ptype, *pvalue, *ptraceback;
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject **cython_runtime_dict;
+#endif
+    if (unlikely(!__pyx_cython_runtime)) {
+        return c_line;
+    }
+    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+#if CYTHON_COMPILING_IN_CPYTHON
+    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
+    if (likely(cython_runtime_dict)) {
+        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
+            use_cline, *cython_runtime_dict,
+            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
+    } else
+#endif
+    {
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      if (use_cline_obj) {
+        use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
+        Py_DECREF(use_cline_obj);
+      } else {
+        PyErr_Clear();
+        use_cline = NULL;
+      }
+    }
+    if (!use_cline) {
+        c_line = 0;
+        PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
+    }
+    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
+        c_line = 0;
+    }
+    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+    return c_line;
+}
+#endif
+
+/* CodeObjectCache */
+    static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+    int start = 0, mid = 0, end = count - 1;
+    if (end >= 0 && code_line > entries[end].code_line) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+
+/* AddTraceback */
+    #include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyObject *py_srcfile = 0;
+    PyObject *py_funcname = 0;
+    #if PY_MAJOR_VERSION < 3
+    py_srcfile = PyString_FromString(filename);
+    #else
+    py_srcfile = PyUnicode_FromString(filename);
+    #endif
+    if (!py_srcfile) goto bad;
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        #else
+        py_funcname = PyUnicode_FromString(funcname);
+        #endif
+    }
+    if (!py_funcname) goto bad;
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    Py_DECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_srcfile);
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    if (c_line) {
+        c_line = __Pyx_CLineForTraceback(tstate, c_line);
+    }
+    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) goto bad;
+        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        tstate,            /*PyThreadState *tstate,*/
+        py_code,           /*PyCodeObject *code,*/
+        __pyx_d,    /*PyObject *globals,*/
+        0                  /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+
+#if PY_MAJOR_VERSION < 3
+static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
+    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
+        if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
+        if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags);
+        if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags);
+    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
+    return -1;
+}
+static void __Pyx_ReleaseBuffer(Py_buffer *view) {
+    PyObject *obj = view->obj;
+    if (!obj) return;
+    if (PyObject_CheckBuffer(obj)) {
+        PyBuffer_Release(view);
+        return;
+    }
+    if ((0)) {}
+        else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view);
+    view->obj = NULL;
+    Py_DECREF(obj);
+}
+#endif
+
+
+    /* MemviewSliceIsContig */
+    static int
+__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim)
+{
+    int i, index, step, start;
+    Py_ssize_t itemsize = mvs.memview->view.itemsize;
+    if (order == 'F') {
+        step = 1;
+        start = 0;
+    } else {
+        step = -1;
+        start = ndim - 1;
+    }
+    for (i = 0; i < ndim; i++) {
+        index = start + step * i;
+        if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize)
+            return 0;
+        itemsize *= mvs.shape[index];
+    }
+    return 1;
+}
+
+/* OverlappingSlices */
+    static void
+__pyx_get_array_memory_extents(__Pyx_memviewslice *slice,
+                               void **out_start, void **out_end,
+                               int ndim, size_t itemsize)
+{
+    char *start, *end;
+    int i;
+    start = end = slice->data;
+    for (i = 0; i < ndim; i++) {
+        Py_ssize_t stride = slice->strides[i];
+        Py_ssize_t extent = slice->shape[i];
+        if (extent == 0) {
+            *out_start = *out_end = start;
+            return;
+        } else {
+            if (stride > 0)
+                end += stride * (extent - 1);
+            else
+                start += stride * (extent - 1);
+        }
+    }
+    *out_start = start;
+    *out_end = end + itemsize;
+}
+static int
+__pyx_slices_overlap(__Pyx_memviewslice *slice1,
+                     __Pyx_memviewslice *slice2,
+                     int ndim, size_t itemsize)
+{
+    void *start1, *end1, *start2, *end2;
+    __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize);
+    __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize);
+    return (start1 < end2) && (start2 < end1);
+}
+
+/* Capsule */
+    static CYTHON_INLINE PyObject *
+__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig)
+{
+    PyObject *cobj;
+#if PY_VERSION_HEX >= 0x02070000
+    cobj = PyCapsule_New(p, sig, NULL);
+#else
+    cobj = PyCObject_FromVoidPtr(p, NULL);
+#endif
+    return cobj;
+}
+
+/* CIntToPy */
+    static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+    const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+    static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+    const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPyVerify */
+    #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* CIntToPy */
+    static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) {
+    const Py_intptr_t neg_one = (Py_intptr_t) ((Py_intptr_t) 0 - (Py_intptr_t) 1), const_zero = (Py_intptr_t) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(Py_intptr_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(Py_intptr_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* Declarations */
+    #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return ::std::complex< float >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return x + y*(__pyx_t_float_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      __pyx_t_float_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+    #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabsf(b.real) >= fabsf(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                float r = b.imag / b.real;
+                float s = (float)(1.0) / (b.real + b.imag * r);
+                return __pyx_t_float_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            float r = b.real / b.imag;
+            float s = (float)(1.0) / (b.imag + b.real * r);
+            return __pyx_t_float_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            float denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_float_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrtf(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypotf(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+            __pyx_t_float_complex z;
+            float r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    float denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        return __Pyx_c_prod_float(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = powf(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2f(0.0, -1.0);
+                }
+            } else {
+                r = __Pyx_c_abs_float(a);
+                theta = atan2f(a.imag, a.real);
+            }
+            lnr = logf(r);
+            z_r = expf(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cosf(z_theta);
+            z.imag = z_r * sinf(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* Declarations */
+    #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return ::std::complex< double >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return x + y*(__pyx_t_double_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      __pyx_t_double_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+    #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabs(b.real) >= fabs(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                double r = b.imag / b.real;
+                double s = (double)(1.0) / (b.real + b.imag * r);
+                return __pyx_t_double_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            double r = b.real / b.imag;
+            double s = (double)(1.0) / (b.imag + b.real * r);
+            return __pyx_t_double_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            double denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_double_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrt(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypot(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+            __pyx_t_double_complex z;
+            double r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    double denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        return __Pyx_c_prod_double(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = pow(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2(0.0, -1.0);
+                }
+            } else {
+                r = __Pyx_c_abs_double(a);
+                theta = atan2(a.imag, a.real);
+            }
+            lnr = log(r);
+            z_r = exp(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cos(z_theta);
+            z.imag = z_r * sin(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* CIntToPy */
+    static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
+    const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(enum NPY_TYPES) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
+                                     little, !is_unsigned);
+    }
+}
+
+/* MemviewSliceCopyTemplate */
+    static __Pyx_memviewslice
+__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
+                                 const char *mode, int ndim,
+                                 size_t sizeof_dtype, int contig_flag,
+                                 int dtype_is_object)
+{
+    __Pyx_RefNannyDeclarations
+    int i;
+    __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } };
+    struct __pyx_memoryview_obj *from_memview = from_mvs->memview;
+    Py_buffer *buf = &from_memview->view;
+    PyObject *shape_tuple = NULL;
+    PyObject *temp_int = NULL;
+    struct __pyx_array_obj *array_obj = NULL;
+    struct __pyx_memoryview_obj *memview_obj = NULL;
+    __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0);
+    for (i = 0; i < ndim; i++) {
+        if (unlikely(from_mvs->suboffsets[i] >= 0)) {
+            PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with "
+                                           "indirect dimensions (axis %d)", i);
+            goto fail;
+        }
+    }
+    shape_tuple = PyTuple_New(ndim);
+    if (unlikely(!shape_tuple)) {
+        goto fail;
+    }
+    __Pyx_GOTREF(shape_tuple);
+    for(i = 0; i < ndim; i++) {
+        temp_int = PyInt_FromSsize_t(from_mvs->shape[i]);
+        if(unlikely(!temp_int)) {
+            goto fail;
+        } else {
+            PyTuple_SET_ITEM(shape_tuple, i, temp_int);
+            temp_int = NULL;
+        }
+    }
+    array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL);
+    if (unlikely(!array_obj)) {
+        goto fail;
+    }
+    __Pyx_GOTREF(array_obj);
+    memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
+                                    (PyObject *) array_obj, contig_flag,
+                                    dtype_is_object,
+                                    from_mvs->memview->typeinfo);
+    if (unlikely(!memview_obj))
+        goto fail;
+    if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0))
+        goto fail;
+    if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim,
+                                                dtype_is_object) < 0))
+        goto fail;
+    goto no_fail;
+fail:
+    __Pyx_XDECREF(new_mvs.memview);
+    new_mvs.memview = NULL;
+    new_mvs.data = NULL;
+no_fail:
+    __Pyx_XDECREF(shape_tuple);
+    __Pyx_XDECREF(temp_int);
+    __Pyx_XDECREF(array_obj);
+    __Pyx_RefNannyFinishContext();
+    return new_mvs;
+}
+
+/* CIntFromPy */
+    static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+    const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(int) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(int) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (int) -1;
+        }
+    } else {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* CIntFromPy */
+    static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+    const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (long) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(long) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(long) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            long val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (long) -1;
+        }
+    } else {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* CIntFromPy */
+    static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) {
+    const char neg_one = (char) ((char) 0 - (char) 1), const_zero = (char) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(char) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (char) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (char) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(char) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) {
+                            return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(char) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) {
+                            return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(char) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) {
+                            return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (char) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(char) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (char) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(char,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
+                            return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(char) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
+                            return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
+                            return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(char) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
+                            return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) {
+                            return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(char) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) {
+                            return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(char) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            char val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (char) -1;
+        }
+    } else {
+        char val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (char) -1;
+        val = __Pyx_PyInt_As_char(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to char");
+    return (char) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to char");
+    return (char) -1;
+}
+
+/* TypeInfoCompare */
+    static int
+__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b)
+{
+    int i;
+    if (!a || !b)
+        return 0;
+    if (a == b)
+        return 1;
+    if (a->size != b->size || a->typegroup != b->typegroup ||
+            a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) {
+        if (a->typegroup == 'H' || b->typegroup == 'H') {
+            return a->size == b->size;
+        } else {
+            return 0;
+        }
+    }
+    if (a->ndim) {
+        for (i = 0; i < a->ndim; i++)
+            if (a->arraysize[i] != b->arraysize[i])
+                return 0;
+    }
+    if (a->typegroup == 'S') {
+        if (a->flags != b->flags)
+            return 0;
+        if (a->fields || b->fields) {
+            if (!(a->fields && b->fields))
+                return 0;
+            for (i = 0; a->fields[i].type && b->fields[i].type; i++) {
+                __Pyx_StructField *field_a = a->fields + i;
+                __Pyx_StructField *field_b = b->fields + i;
+                if (field_a->offset != field_b->offset ||
+                    !__pyx_typeinfo_cmp(field_a->type, field_b->type))
+                    return 0;
+            }
+            return !a->fields[i].type && !b->fields[i].type;
+        }
+    }
+    return 1;
+}
+
+/* MemviewSliceValidateAndInit */
+    static int
+__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec)
+{
+    if (buf->shape[dim] <= 1)
+        return 1;
+    if (buf->strides) {
+        if (spec & __Pyx_MEMVIEW_CONTIG) {
+            if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) {
+                if (unlikely(buf->strides[dim] != sizeof(void *))) {
+                    PyErr_Format(PyExc_ValueError,
+                                 "Buffer is not indirectly contiguous "
+                                 "in dimension %d.", dim);
+                    goto fail;
+                }
+            } else if (unlikely(buf->strides[dim] != buf->itemsize)) {
+                PyErr_SetString(PyExc_ValueError,
+                                "Buffer and memoryview are not contiguous "
+                                "in the same dimension.");
+                goto fail;
+            }
+        }
+        if (spec & __Pyx_MEMVIEW_FOLLOW) {
+            Py_ssize_t stride = buf->strides[dim];
+            if (stride < 0)
+                stride = -stride;
+            if (unlikely(stride < buf->itemsize)) {
+                PyErr_SetString(PyExc_ValueError,
+                                "Buffer and memoryview are not contiguous "
+                                "in the same dimension.");
+                goto fail;
+            }
+        }
+    } else {
+        if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) {
+            PyErr_Format(PyExc_ValueError,
+                         "C-contiguous buffer is not contiguous in "
+                         "dimension %d", dim);
+            goto fail;
+        } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) {
+            PyErr_Format(PyExc_ValueError,
+                         "C-contiguous buffer is not indirect in "
+                         "dimension %d", dim);
+            goto fail;
+        } else if (unlikely(buf->suboffsets)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "Buffer exposes suboffsets but no strides");
+            goto fail;
+        }
+    }
+    return 1;
+fail:
+    return 0;
+}
+static int
+__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec)
+{
+    if (spec & __Pyx_MEMVIEW_DIRECT) {
+        if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) {
+            PyErr_Format(PyExc_ValueError,
+                         "Buffer not compatible with direct access "
+                         "in dimension %d.", dim);
+            goto fail;
+        }
+    }
+    if (spec & __Pyx_MEMVIEW_PTR) {
+        if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) {
+            PyErr_Format(PyExc_ValueError,
+                         "Buffer is not indirectly accessible "
+                         "in dimension %d.", dim);
+            goto fail;
+        }
+    }
+    return 1;
+fail:
+    return 0;
+}
+static int
+__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag)
+{
+    int i;
+    if (c_or_f_flag & __Pyx_IS_F_CONTIG) {
+        Py_ssize_t stride = 1;
+        for (i = 0; i < ndim; i++) {
+            if (unlikely(stride * buf->itemsize != buf->strides[i]  &&  buf->shape[i] > 1)) {
+                PyErr_SetString(PyExc_ValueError,
+                    "Buffer not fortran contiguous.");
+                goto fail;
+            }
+            stride = stride * buf->shape[i];
+        }
+    } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) {
+        Py_ssize_t stride = 1;
+        for (i = ndim - 1; i >- 1; i--) {
+            if (unlikely(stride * buf->itemsize != buf->strides[i]  &&  buf->shape[i] > 1)) {
+                PyErr_SetString(PyExc_ValueError,
+                    "Buffer not C contiguous.");
+                goto fail;
+            }
+            stride = stride * buf->shape[i];
+        }
+    }
+    return 1;
+fail:
+    return 0;
+}
+static int __Pyx_ValidateAndInit_memviewslice(
+                int *axes_specs,
+                int c_or_f_flag,
+                int buf_flags,
+                int ndim,
+                __Pyx_TypeInfo *dtype,
+                __Pyx_BufFmt_StackElem stack[],
+                __Pyx_memviewslice *memviewslice,
+                PyObject *original_obj)
+{
+    struct __pyx_memoryview_obj *memview, *new_memview;
+    __Pyx_RefNannyDeclarations
+    Py_buffer *buf;
+    int i, spec = 0, retval = -1;
+    __Pyx_BufFmt_Context ctx;
+    int from_memoryview = __pyx_memoryview_check(original_obj);
+    __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0);
+    if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *)
+                                                            original_obj)->typeinfo)) {
+        memview = (struct __pyx_memoryview_obj *) original_obj;
+        new_memview = NULL;
+    } else {
+        memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
+                                            original_obj, buf_flags, 0, dtype);
+        new_memview = memview;
+        if (unlikely(!memview))
+            goto fail;
+    }
+    buf = &memview->view;
+    if (unlikely(buf->ndim != ndim)) {
+        PyErr_Format(PyExc_ValueError,
+                "Buffer has wrong number of dimensions (expected %d, got %d)",
+                ndim, buf->ndim);
+        goto fail;
+    }
+    if (new_memview) {
+        __Pyx_BufFmt_Init(&ctx, stack, dtype);
+        if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail;
+    }
+    if (unlikely((unsigned) buf->itemsize != dtype->size)) {
+        PyErr_Format(PyExc_ValueError,
+                     "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) "
+                     "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)",
+                     buf->itemsize,
+                     (buf->itemsize > 1) ? "s" : "",
+                     dtype->name,
+                     dtype->size,
+                     (dtype->size > 1) ? "s" : "");
+        goto fail;
+    }
+    if (buf->len > 0) {
+        for (i = 0; i < ndim; i++) {
+            spec = axes_specs[i];
+            if (unlikely(!__pyx_check_strides(buf, i, ndim, spec)))
+                goto fail;
+            if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec)))
+                goto fail;
+        }
+        if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag)))
+            goto fail;
+    }
+    if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice,
+                                         new_memview != NULL) == -1)) {
+        goto fail;
+    }
+    retval = 0;
+    goto no_fail;
+fail:
+    Py_XDECREF(new_memview);
+    retval = -1;
+no_fail:
+    __Pyx_RefNannyFinishContext();
+    return retval;
+}
+
+/* ObjectToMemviewSlice */
+    static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_double(PyObject *obj, int writable_flag) {
+    __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
+    __Pyx_BufFmt_StackElem stack[1];
+    int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) };
+    int retcode;
+    if (obj == Py_None) {
+        result.memview = (struct __pyx_memoryview_obj *) Py_None;
+        return result;
+    }
+    retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0,
+                                                 PyBUF_RECORDS_RO | writable_flag, 2,
+                                                 &__Pyx_TypeInfo_double, stack,
+                                                 &result, obj);
+    if (unlikely(retcode == -1))
+        goto __pyx_fail;
+    return result;
+__pyx_fail:
+    result.memview = NULL;
+    result.data = NULL;
+    return result;
+}
+
+/* CheckBinaryVersion */
+    static int __Pyx_check_binary_version(void) {
+    char ctversion[4], rtversion[4];
+    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
+    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
+    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compiletime version %s of module '%.100s' "
+                      "does not match runtime version %s",
+                      ctversion, __Pyx_MODULE_NAME, rtversion);
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+    return 0;
+}
+
+/* InitStrings */
+    static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION < 3
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } else {
+            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
+        }
+        #else
+        if (t->is_unicode | t->is_str) {
+            if (t->intern) {
+                *t->p = PyUnicode_InternFromString(t->s);
+            } else if (t->encoding) {
+                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
+            } else {
+                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
+            }
+        } else {
+            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
+        }
+        #endif
+        if (!*t->p)
+            return -1;
+        if (PyObject_Hash(*t->p) == -1)
+            return -1;
+        ++t;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+}
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#if !CYTHON_PEP393_ENABLED
+static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    char* defenc_c;
+    PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+    if (!defenc) return NULL;
+    defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    {
+        char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+        char* c;
+        for (c = defenc_c; c < end; c++) {
+            if ((unsigned char) (*c) >= 128) {
+                PyUnicode_AsASCIIString(o);
+                return NULL;
+            }
+        }
+    }
+#endif
+    *length = PyBytes_GET_SIZE(defenc);
+    return defenc_c;
+}
+#else
+static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    if (likely(PyUnicode_IS_ASCII(o))) {
+        *length = PyUnicode_GET_LENGTH(o);
+        return PyUnicode_AsUTF8(o);
+    } else {
+        PyUnicode_AsASCIIString(o);
+        return NULL;
+    }
+#else
+    return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+}
+#endif
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+        return __Pyx_PyUnicode_AsStringAndSize(o, length);
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
+    int retval;
+    if (unlikely(!x)) return -1;
+    retval = __Pyx_PyObject_IsTrue(x);
+    Py_DECREF(x);
+    return retval;
+}
+static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+#if PY_MAJOR_VERSION >= 3
+    if (PyLong_Check(result)) {
+        if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
+                "__int__ returned non-int (type %.200s).  "
+                "The ability to return an instance of a strict subclass of int "
+                "is deprecated, and may be removed in a future version of Python.",
+                Py_TYPE(result)->tp_name)) {
+            Py_DECREF(result);
+            return NULL;
+        }
+        return result;
+    }
+#endif
+    PyErr_Format(PyExc_TypeError,
+                 "__%.4s__ returned non-%.4s (type %.200s)",
+                 type_name, type_name, Py_TYPE(result)->tp_name);
+    Py_DECREF(result);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_Check(x) || PyLong_Check(x)))
+#else
+  if (likely(PyLong_Check(x)))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = m->nb_long(x);
+  }
+  #else
+  if (likely(m && m->nb_int)) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  #endif
+#else
+  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
+    res = PyNumber_Int(x);
+  }
+#endif
+  if (likely(res)) {
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
+#else
+    if (unlikely(!PyLong_CheckExact(res))) {
+#endif
+        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(b);
+  }
+#endif
+  if (likely(PyLong_CheckExact(b))) {
+    #if CYTHON_USE_PYLONG_INTERNALS
+    const digit* digits = ((PyLongObject*)b)->ob_digit;
+    const Py_ssize_t size = Py_SIZE(b);
+    if (likely(__Pyx_sst_abs(size) <= 1)) {
+        ival = likely(size) ? digits[0] : 0;
+        if (size == -1) ival = -ival;
+        return ival;
+    } else {
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             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]));
+           }
+           break;
+         case -4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             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]));
+           }
+           break;
+      }
+    }
+    #endif
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
+  return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */

From 46f4f88c026fe0276a1cbb3562a1c0f87145f10a Mon Sep 17 00:00:00 2001
From: Shrey A 
Date: Sat, 26 Jun 2021 14:13:46 -0700
Subject: [PATCH 41/43] add prange changes

---
 .../prange_saliency_mbd.pyx                   | 47 ++++++++++++++-----
 1 file changed, 34 insertions(+), 13 deletions(-)

diff --git a/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx b/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx
index bebd5ab..fc582d3 100644
--- a/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx
+++ b/perception/tasks/segmentation/saliency_detection/prange_saliency_mbd.pyx
@@ -48,17 +48,21 @@ cdef raster_scan(double [:,:] img, double [:,:] L, double [:,:] U, double [:,:]
 
 			b1 = max(u1,ix) - min(l1,ix)
 			b2 = max(u2,ix) - min(l2,ix)
-
+			
 			if d <= b1 and d <= b2:
 				continue
 			elif b1 < d and b1 <= b2:
-				D[x:x+res,y:y+res] = b1
-				U[x:x+res,y:y+res] = max(u1,ix)
-				L[x:x+res,y:y+res] = min(l1,ix)
+				for i in xrange(x,x+res):
+					for j in xrange(y, y+y+res):
+						D[x:x+res,y:y+res] = b1
+						U[x:x+res,y:y+res] = max(u1,ix)
+						L[x:x+res,y:y+res] = min(l1,ix)
 			else:
-				D[x:x+res,y:y+res] = b2
-				U[x:x+res,y:y+res] = max(u2,ix)
-				L[x:x+res,y:y+res] = min(l2,ix)
+				for i in xrange(x,x+res):
+					for j in xrange(y, y+y+res):
+						D[x:x+res,y:y+res] = b2
+						U[x:x+res,y:y+res] = max(u2,ix)
+						L[x:x+res,y:y+res] = min(l2,ix)
 
 	return True
 
@@ -105,13 +109,30 @@ cdef raster_scan_inv(double [:,:] img, double [:,:] L, double [:,:] U, double [:
 			if d <= b1 and d <= b2:
 				continue
 			elif b1 < d and b1 <= b2:
-				D[x:x+res,y:y+res] = b1
-				U[x:x+res,y:y+res] = max(u1,ix)
-				L[x:x+res,y:y+res] = min(l1,ix)
+				v1 = max(u1,ix)
+				v2 = min(l1,ix)
+				for i in xrange(x,x+res):
+					for j in xrange(y, y+y+res):
+						D[x:x+res,y:y+res] = b1
+						U[x:x+res,y:y+res] = v1
+						L[x:x+res,y:y+res] = v2
 			else:
-				D[x:x+res,y:y+res] = b2
-				U[x:x+res,y:y+res] = max(u2,ix)
-				L[x:x+res,y:y+res] = min(l2,ix)
+				v1 = max(u2,ix)
+				v2 = min(l2,ix)
+				for i in xrange(x,x+res):
+					for j in xrange(y, y+y+res):
+						D[x:x+res,y:y+res] = b2
+						U[x:x+res,y:y+res] = v1
+						L[x:x+res,y:y+res] = v2
+
+			# elif b1 < d and b1 <= b2:
+			# 	D[x:x+res,y:y+res] = b1
+			# 	U[x:x+res,y:y+res] = max(u1,ix)
+			# 	L[x:x+res,y:y+res] = min(l1,ix)
+			# else:
+			# 	D[x:x+res,y:y+res] = b2
+			# 	U[x:x+res,y:y+res] = max(u2,ix)
+			# 	L[x:x+res,y:y+res] = min(l2,ix)
 
 	return True
 

From 1cd369a041e8b0bd445f5e9dcc400515154838a6 Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 14 Nov 2021 15:51:03 -0800
Subject: [PATCH 42/43] Updated README

---
 README.md | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index b0a5543..1f6fc47 100644
--- a/README.md
+++ b/README.md
@@ -13,25 +13,24 @@ activate it with
 
     conda activate urobotics
 
-and install all dependencies with
-
-    pip3 install -r requirements.txt
-
 Then clone the repo in a directory of your choice
 
     git clone https://github.com/berkeleyauv/perception.git
 
-and install it
+and change directory to the cloned directory and install all dependencies with
+
+    pip3 install -r requirements.txt
+
+Then install the perception module with
 
     pip3 install -e perception/
 
 Also, our training data is stored here https://www.dropbox.com/sh/rrbfqfutrmifrxs/AAAfXxlcCtWZmUELp4wXyTIxa?dl=0 so download it and unzip it in the same folder as `perception`.
 
 ### Cython
-To compile cythonized code, run the following commands after `cd`ing into the folder with Cython `setup.py`
+To compile cythonized code, run the following commands after `cd`ing into the folder with Cython `setup.py` (`perception/tasks/segmentation/saliency_detection`)
 
     python setup.py build_ext --inplace
-    cythonize file_to_cythonize.pyx
 
 
 ## misc:

From 404e1191dae100a045b3d993bafd59207c4b1ba3 Mon Sep 17 00:00:00 2001
From: Karthik Dharmarajan 
Date: Sun, 14 Nov 2021 16:12:52 -0800
Subject: [PATCH 43/43] Fixed contours in python version

---
 perception/tasks/segmentation/COMB_SAL_BG.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/perception/tasks/segmentation/COMB_SAL_BG.py b/perception/tasks/segmentation/COMB_SAL_BG.py
index 09d9fba..5b8a5ae 100644
--- a/perception/tasks/segmentation/COMB_SAL_BG.py
+++ b/perception/tasks/segmentation/COMB_SAL_BG.py
@@ -27,7 +27,7 @@ def largest_contour(self, contours):
         return max(contours, key=cv.contourArea)
 
     def largest_contours(self, contours):
-        contours.sort(key=cv.contourArea)
+        contours = sorted(contours, key=cv.contourArea)
         num_selected = self.num_contours
         if len(contours) < num_selected:
             num_selected = len(contours)