def calibrate(self): # Get the pattern parameters h_dim = utils.getAnswer( "Number of inner corners on the horizontal dimension ? ", '12345678910') v_dim = utils.getAnswer( "Number of inner corners on the vertical dimension ? ", '12345678910') # Enter the number of squares over each dimensions self.pattern_size = (int(h_dim), int(v_dim)) print "Chessboard dimensions : {} x {}"\ .format(self.pattern_size[0], self.pattern_size[1]) get_square_size = False while not (get_square_size): sq_size = raw_input("Horizontal Size (in m) of the squares ? ") try: self.sq_size_h = float(sq_size) get_square_size = True except ValueError: print "Cannot determine dimension" get_square_size = False while not (get_square_size): sq_size = raw_input("Vertical Size (in m) of the squares ? ") try: self.sq_size_v = float(sq_size) get_square_size = True except ValueError: print "Cannot determine dimension" # Get the root folder, Get all the subfolders, # do all the subsequent calibrations and record the results path = raw_input("Root path for the calibration folders : ") for dirpath, dirnames, filenames in os.walk(path): for dir in dirnames: if not dir[0] == '.': path = dirpath + dir settings = (False, True, True, True, path, self.pattern_size, (self.sq_size_h, self.sq_size_v), False) new_cam = cam_calib.cameraCalibration(settings) print "\nCalibrating using files in folder : {}".format( dir) if (os.path.exists(path + '/calib_results.txt')): print "Folder {} already contains calibration results" else: new_cam.calibrate()
def calibrate(self): # Get the pattern parameters h_dim = utils.getAnswer( "Number of inner corners on the horizontal dimension ? ", '12345678910') v_dim = utils.getAnswer( "Number of inner corners on the vertical dimension ? ", '12345678910') # Enter the number of squares over each dimensions self.pattern_size = (int(h_dim), int(v_dim)) print "Chessboard dimensions : {} x {}"\ .format(self.pattern_size[0], self.pattern_size[1]) get_square_size = False while not(get_square_size): sq_size = raw_input("Horizontal Size (in m) of the squares ? ") try: self.sq_size_h = float(sq_size) get_square_size = True except ValueError: print "Cannot determine dimension" get_square_size = False while not(get_square_size): sq_size = raw_input("Vertical Size (in m) of the squares ? ") try: self.sq_size_v = float(sq_size) get_square_size = True except ValueError: print "Cannot determine dimension" # Get the root folder, Get all the subfolders, # do all the subsequent calibrations and record the results path = raw_input("Root path for the calibration folders : ") for dirpath, dirnames, filenames in os.walk(path): for dir in dirnames : if not dir[0] == '.': path = dirpath + dir settings = (False, True, True, True, path, self.pattern_size , (self.sq_size_h,self.sq_size_v), False) new_cam = cam_calib.cameraCalibration(settings) print "\nCalibrating using files in folder : {}".format(dir) if (os.path.exists(path +'/calib_results.txt')): print "Folder {} already contains calibration results" else : new_cam.calibrate()
def _record_pattern_cam(self): n_frames = 0 pattern_points = np.zeros((np.prod(self.params.pattern_size), 3), np.float32) pattern_points[:, :2] = np.indices(self.params.pattern_size).T.reshape(-1, 2) cv2.namedWindow("captureStream", cv2.CV_WINDOW_AUTOSIZE) cv2.namedWindow("patternDetection", cv2.CV_WINDOW_AUTOSIZE) save_files = utils.getAnswer("Would you like to save picture files ? (y/n)", 'yn') == 'y' finished_parsing = False cam_online = utils.getCam() if cam_online: while not finished_parsing and (self.params.max_frames_i == -1 or n_frames < self.params.max_frames_i): success, new_frame = cam_online.read() if success: # Convert to B&W (if necessary ?) grey_frame = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) found, corners = cv2.findChessboardCorners(grey_frame, self.params.pattern_size) cv2.imshow("captureStream", new_frame) cv2.waitKey(2) if found: # Refine position term = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_COUNT, 30, 0.1) cv2.cornerSubPix(grey_frame, corners, (11, 11), (-1, -1), term) # Draw detected pattern cv2.drawChessboardCorners(new_frame, self.params.pattern_size, corners, found) cv2.imshow("patternDetection", new_frame) cv2.waitKey() # Store values self.img_points.append(corners.reshape(-1, 2)) self.obj_points.append(pattern_points) n_frames += 1 print("{} patterns found".format(n_frames)) if save_files: cv2.imwrite("calib_{}.bmp".format(n_frames), grey_frame) cv2.imwrite("calib_{}_pattern.bmp_".format(n_frames), new_frame) self.frame_size = (len(new_frame[0]), len(new_frame)) cv2.destroyAllWindows()
def calibrate(self): # If calibration type is unkown at this point, ask the user if (self.stereo == None): calib_type = utils.getAnswer('Stereo or Mono calibration ? (s/m) : ', 'sm') if (calib_type == 's'): self.stereo = True else: self.stereo = False # Start the appropriate calibration processes if self.stereo: self.stereoCalibrate() else : self.monoCalibrate()
def calibrate(self): # If calibration type is unkown at this point, ask the user if (self.stereo == None): calib_type = utils.getAnswer( 'Stereo or Mono calibration ? (s/m) : ', 'sm') if (calib_type == 's'): self.stereo = True else: self.stereo = False # Start the appropriate calibration processes if self.stereo: self.stereoCalibrate() else: self.monoCalibrate()
def stereoCalibrate(self): print "If you calibrate from files, make sure stereo files are" print "in the left-right-left-right order" # Get settings & files self.stereo = True self.chooseCalibrationSettings() # Get patterns self.recordPatterns() # Compute the intrisic parameters first : rvecs = [ np.zeros(3, dtype=np.float32) for i in xrange(self.max_frames_i) ] tvecs = [ np.zeros(3, dtype=np.float32) for i in xrange(self.max_frames_i) ] # Call OpenCV routines to do the dirty work print "Computing intrisic parameters for the first camera" res = cv2.calibrateCamera(self.obj_points_l, self.img_points_l, self.frame_size, self.intrinsics_l, self.distorsion_l, rvecs, tvecs) rms, self.intrinsics_l, self.distorsion_l, rvecs, tvecs = res print "Computing intrisic parameters for the second camera" res = cv2.calibrateCamera(self.obj_points_r, self.img_points_r, self.frame_size, self.intrinsics_r, self.distorsion_r, rvecs, tvecs) rms, self.intrinsics_r, self.distorsion_r, rvecs, tvecs = res # Allocate arrays for the two camera matrix and distorsion matrices R = np.zeros((3, 3), dtype=np.float32) T = np.zeros((3, 1), dtype=np.float32) E = np.zeros((3, 3), dtype=np.float32) F = np.zeros((3, 3), dtype=np.float32) # Compute calibration parameters : print "Calibrating cameras.." print "Frame size : {}".format(self.frame_size) # set stereo flags stereo_flags = 0 # stereo_flags |= cv2.CALIB_FIX_INTRINSIC stereo_flags |= cv2.CALIB_USE_INTRINSIC_GUESS # Refine intrinsic parameters # stereo_flags |= cv2.CALIB_FIX_PRINCIPAL_POINT # Fix the principal points during the optimization. # stereo_flags |= cv2.CALIB_FIX_FOCAL_LENGTH # Fix focal length # stereo_flags |= cv2.CALIB_FIX_ASPECT_RATIO # fix aspect ratio stereo_flags |= cv2.CALIB_SAME_FOCAL_LENGTH # Use same focal length # stereo_flags |= cv2.CALIB_ZERO_TANGENT_DIST # Set tangential distortion to zero # stereo_flags |= cv2.CALIB_RATIONAL_MODEL # Use 8 param rational distortion model instead of 5 param plumb bob model res = cv2.stereoCalibrate(self.obj_points_l, self.img_points_l, self.img_points_r, self.frame_size, self.intrinsics_l, self.distorsion_l, self.intrinsics_r, self.distorsion_r) # flags=stereo_flags (rms, int_left, dist_left, int_right, dist_right, R, T, E, F) = res # Output print "Calibration done" print "Residual RMS : {}".format(rms) if (rms > 1.0): print "Calibration looks faulty, please re-run" print "\nCalibration parameters : \n Intrinsics -left \n {} \n\n Distorsion -left\n {}".format(\ int_left, dist_left) print "\nCalibration parameters : \n Intrinsics -right \n {} \n\n Distorsion -right\n {}".format(\ int_right, dist_right) print "\nRotation : \n{}\n".format(R) print "\nTranslation : \n{}\n".format(T) print "\nEssential matrix : \n{}\n".format(E) # Essential matrix print "\nFundamental matrix : \n{}\n".format(F) # Fundamental matrix # TODO : Compute perspective matrix ! # Save calibration parameters save_file = utils.getAnswer( "Would you like to save the results ? (y/n) ", 'yn') b_write_success = False if save_file == "y": while (b_write_success == False): save_XML = utils.getAnswer("Save in XML format ? (y/n) ", "yn") filepath = raw_input( "Where do you want to save the file ? (enter file path) ") try: if (save_XML): file = utils.handlePath(filepath, "camera_calibration.xml") utils.saveParametersXML(int_left, dist_left, int_right, dist_right, R, T, self.frame_size, file) else: file_left = utils.handlePath(filepath, "_left.txt") utils.saveParameters(int_left, dist_left, R, T, file_left) file_right = utils.handlePath(filepath, "_right.txt") utils.saveParameters(int_right, dist_right, R, T, file_right) print "Parameters file written" b_write_success = True except: print "Wrong path, please correct" time.sleep(2) return
def recordPattern_cam(self): n_frames = 0 pattern_points = np.zeros((np.prod(self.pattern_size), 3),\ np.float32) pattern_points[:, :2] = np.indices(self.pattern_size).T\ .reshape(-1, 2) cv2.namedWindow("captureStream", cv2.CV_WINDOW_AUTOSIZE) cv2.namedWindow("patternDetection", cv2.CV_WINDOW_AUTOSIZE) save_files = utils.getAnswer( "Would you like \ to save picture files ? (y/n) ", 'yn') finished_parsing = False if (self.cam != ''): while not (finished_parsing) and ((self.max_frames_i == -1) or (n_frames < self.max_frames_i)): success, new_frame = self.cam.read() if (success): grey_frame = np.array([]) corners = np.array([]) # Convert to B&W (if necessary ?) grey_frame = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) found, corners = cv2.findChessboardCorners(\ grey_frame, self.pattern_size) cv2.imshow("captureStream", new_frame) cv2.waitKey(2) if found: # Refine position term = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_COUNT, 30, 0.1) cv2.cornerSubPix(grey_frame, corners, (11, 11), (-1, -1), term) # Draw detected pattern cv2.drawChessboardCorners(new_frame, self.pattern_size, corners, found) cv2.imshow("patternDetection", new_frame) cv2.waitKey() # Store values self.img_points.append(corners.reshape(-1, 2)) self.obj_points.append(pattern_points) n_frames = n_frames + 1 print "{} patterns found".format(n_frames) if save_files == 'y': cv2.imwrite("calib_{}.bmp".format(n_frames), grey_frame) cv2.imwrite( "calib_{}_pattern.bmp_".format(n_frames), new_frame) self.frame_size = (len(new_frame[0]), len(new_frame)) cv2.destroyAllWindows()
def chooseCalibrationSettings(self): # Get the path where all the files are stored if (len(self.file_path) == 0): file_read = False while not file_read: path = raw_input("Path for the calibration files : ") file_read = self.readFiles(path) self.file_path = path else: file_read = self.readFiles(self.file_path) # Get the pattern dimensions in terms of patch number: if (self.pattern_size == (0, 0)): h_dim = utils.getAnswer( "Number of inner corners on the horizontal dimension ? ", '12345678910') v_dim = utils.getAnswer( "Number of inner corners on the vertical dimension ? ", '12345678910') # Enter the number of squares over each dimensions self.pattern_size = (int(h_dim), int(v_dim)) print "Chessboard dimensions : {} x {}"\ .format(self.pattern_size[0], self.pattern_size[1]) # Get every patch dimension : if ((self.sq_size_h, self.sq_size_v) == (0.0, 0.0)): get_square_size = False while not (get_square_size): sq_size = raw_input("Horizontal Size (in m) of the squares ? ") try: self.sq_size_h = float(sq_size) get_square_size = True except ValueError: print "Cannot determine dimension" get_square_size = False while not (get_square_size): sq_size = raw_input("Vertical Size (in m) of the squares ? ") try: self.sq_size_v = float(sq_size) get_square_size = True except ValueError: print "Cannot determine dimension" # Get the max number of frames: if (self.max_frames_i != -1): get_max_frames = False while not (get_max_frames): max_frames = raw_input("How many frames ? ") try: self.max_frames_i = int(max_frames) get_max_frames = True except ValueError: print "Cannot determine max number of frames"
# -*- coding: utf-8 -*- import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Getting Orders utils.parameters['limit'] = 2 utils.getAnswer(utils.getUrl('pedidos?'), requests.get) # Posting new SalesOrders utils.init() p = {} p['referencia'] = '123456' p['fecha_pedido'] = '2019-12-01T10:00:00' p['fecha_autoriza'] = '2019-12-01T10:35:10' p['subtotal'] = '1000' p['total'] = '1160' p['email'] = '*****@*****.**' p['entregara'] = 'MySelf' p['telefono'] = '' p['direccion'] = 'Priv Reforma # 108' p['entrecalles'] = 'Abasolo y Montero' p['colonia'] = 'Los Treviño' p['ciudad'] = 'Santa Catarina' p['estado'] = 'Nuevo León' p['observaciones'] = 'Bodega Blanca' p['cp'] = '61588' p['estatus'] = 'pendiente' p['mensajeria'] = '' p['guias'] = ''
# -*- coding: utf-8 -*- import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Getting Kits # utils.parameters['beforeid'] = # utils.parameters['afterid'] = utils.parameters['ids'] = "5999" utils.getAnswer(utils.getUrl('kits?'), requests.get) utils.init() p = [] componentes = [] componentes.append({"sku": '12345698', 'cantidad': 1}) p.append({ 'sku': '123456', 'comentario': 'Prueba de post', "componentes": componentes }) utils.getAnswer(utils.getUrl('kits?'), requests.post, p)
import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Getting countries utils.getAnswer(utils.getUrl('paises?'), requests.get)
def _choose_calibration_settings(self): # Get the path where all the files are stored if len(self.params.file_path) == 0: file_read = False path = None while not file_read: path = raw_input("Path for the calibration files : ") file_read = self._read_files(path) self.params.file_path = path else: self._read_files(self.params.file_path) # Get the pattern dimensions in terms of patch number: if self.params.pattern_size == (0, 0): h_dim = utils.getAnswer("Number of inner corners on the horizontal dimension ? ", '12345678910') v_dim = utils.getAnswer("Number of inner corners on the vertical dimension ? ", '12345678910') # Enter the number of squares over each dimensions self.params.pattern_size = (int(h_dim), int(v_dim)) print("Chessboard dimensions : {} x {}".format(self.params.pattern_size[0], self.params.pattern_size[1])) # Get every patch dimension : if (self.params.sq_size_h, self.params.sq_size_v) == (0.0, 0.0): get_square_size = False while not get_square_size: sq_size = raw_input("Horizontal Size (in m) of the squares ? ") try: self.params.sq_size_h = float(sq_size) get_square_size = True except ValueError: print("Cannot determine dimension") get_square_size = False while not get_square_size: sq_size = raw_input("Vertical Size (in m) of the squares ? ") try: self.params.sq_size_v = float(sq_size) get_square_size = True except ValueError: print ("Cannot determine dimension") # Get the max number of frames: if self.params.max_frames_i != -1: get_max_frames = False while not get_max_frames: max_frames = raw_input("How many frames ? ") try: self.params.max_frames_i = int(max_frames) get_max_frames = True except ValueError: print "Cannot determine max number of frames"
def monoCalibrate(self): # Get settings self.chooseCalibrationSettings() # Get patterns self.recordPatterns() # Compute intrinsic parameters rvecs = [np.zeros(3) for i in xrange(self.max_frames_i)] # Rotation and translation matrix tvecs = [np.zeros(3) for i in xrange(self.max_frames_i)] _obj_points = np.array(self.obj_points, dtype = np.float32) _img_points = np.array(self.img_points, dtype = np.float32) rms, self.intrinsics, self.distorsion, _rvecs, _tvecs = cv2.calibrateCamera(_obj_points, _img_points, self.frame_size, self.intrinsics, self.distorsion, rvecs, tvecs) print "Calibration done" np.set_printoptions(precision=2) np.set_printoptions(suppress=True) # TODO: cleanup print output, looks like a mess print "Residual RMS (pxl units) :\n" print(rms) print "\nRotations :\n" print(rvecs) print "\nTranslations :\n" print(tvecs) print "\nCalibration parameters :" print "Intrinsics \n" print(self.intrinsics) print "Distorsion \n" print(self.distorsion) # Save calibration parameters if not(self.auto_save): save_file = utils.getAnswer("Would you like to save the results ? (y/n) ", 'yn') b_write_success = False if save_file == "y" : while(b_write_success == False) : filepath = raw_input("Where do you want to save the file ? (enter file path) ") filepath = utils.handlePath(filepath, "calib_results.txt") # Create a file object in "write" mode try : utils.saveParameters(self.intrinsics, self.distorsion, rvecs, tvecs, rms, filepath) b_write_success = True except : print "Wrong path, please correct" time.sleep(2) else: calib_file_path = utils.handlePath(self.file_path, "calib_results.txt") utils.saveParameters(self.intrinsics, self.distorsion, rvecs, tvecs, rms, calib_file_path) print "Saved calibration file" return
# -*- coding: utf-8 -*- import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Getting Tracking Numbers utils.parameters['orders'] = '131303' # utils.parameters['beforeid'] = # utils.parameters['afterid'] = # Genera la guia y la descarga, solamente una guia a la vez utils.getAnswer(utils.getUrl('guias?'), requests.post) # El get funciona para multiples guias pero solamente las descarga ya deben de existir #utils.getAnswer(utils.getUrl('guias?'), requests.get)
v['bullet1'] = 'Lorem Ipsum is simply dummy text of the printing and typesetting industry.' v['bullet2'] = 'Lorem Ipsum has been the industry s standard dummy text ever since the 1500s' v['bullet3'] = '' v['bullet4'] = '' v['bullet5'] = '' v['atributos'] = [{ 'atributo': 'EAN', 'valor': '9856472536978' }, { 'atributo': 'SELLER_SKU', 'valor': '9815-1' }] items = [v] utils.getAnswer(utils.getUrl('variacion?'), requests.post, items) # PUT Variacion utils.init() v = {} v['product_id'] = 163766 v['sku'] = '9815-1' v['color'] = "Negro Noche" v['base'] = "Negro".upper() # ;ist be upper case v['stock'] = 0 v['imagen1'] = 'https://www.w3schools.com/w3css/img_lights.jpg' v['imagen2'] = 'https://www.w3schools.com/w3css/img_snowtops2.jpg' v['imagen3'] = 'https://www.w3schools.com/w3css/img_snowtops3.jpg' v['imagen4'] = 'https://www.w3schools.com/w3css/img_snowtops4.jpg' v['imagen5'] = ''
import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Getting colors utils.getAnswer(utils.getUrl('colores?'), requests.get)
# -*- coding: utf-8 -*- import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Getting Kits # utils.parameters['beforeid'] = # utils.parameters['afterid'] = utils.parameters['orders'] = "1052" utils.getAnswer(utils.getUrl('cobros?'), requests.get) # utils.init() # utils.parameters['orders'] = "1052" # p={ # 'caja':'5', # 'monto':'659', # 'sucursal':'La Fe', # 'ticket':'123456' # } # utils.getAnswer(utils.getUrl('cobros?'), requests.post, [p]) # utils.init() # utils.parameters['ids'] = "4" # p={ # 'motivo':'Cliente se arrepintio', # } # utils.getAnswer(utils.getUrl('cobros?'), requests.put, [p])
import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Getting stand alone category utils.parameters['ids'] = 7209 # remover this parameter to get all categories utils.getAnswer(utils.getUrl('categorias?'), requests.get) # Getting attributes from a category utils.getAnswer(utils.getUrl('categorias/atributos/7416?'), requests.get)
def monoCalibrate(self): # Get settings self.chooseCalibrationSettings() # Get patterns self.recordPatterns() # Compute intrinsic parameters rvecs = [np.zeros(3) for i in xrange(self.max_frames_i) ] # Rotation and translation matrix tvecs = [np.zeros(3) for i in xrange(self.max_frames_i)] _obj_points = np.array(self.obj_points, dtype=np.float32) _img_points = np.array(self.img_points, dtype=np.float32) rms, self.intrinsics, self.distorsion, _rvecs, _tvecs = cv2.calibrateCamera( _obj_points, _img_points, self.frame_size, self.intrinsics, self.distorsion, rvecs, tvecs) print "Calibration done" np.set_printoptions(precision=2) np.set_printoptions(suppress=True) # TODO: cleanup print output, looks like a mess print "Residual RMS (pxl units) :\n" print(rms) print "\nRotations :\n" print(rvecs) print "\nTranslations :\n" print(tvecs) print "\nCalibration parameters :" print "Intrinsics \n" print(self.intrinsics) print "Distorsion \n" print(self.distorsion) # Save calibration parameters if not (self.auto_save): save_file = utils.getAnswer( "Would you like to save the results ? (y/n) ", 'yn') b_write_success = False if save_file == "y": while (b_write_success == False): filepath = raw_input( "Where do you want to save the file ? (enter file path) " ) filepath = utils.handlePath(filepath, "calib_results.txt") # Create a file object in "write" mode try: utils.saveParameters(self.intrinsics, self.distorsion, rvecs, tvecs, rms, filepath) b_write_success = True except: print "Wrong path, please correct" time.sleep(2) else: calib_file_path = utils.handlePath(self.file_path, "calib_results.txt") utils.saveParameters(self.intrinsics, self.distorsion, rvecs, tvecs, rms, calib_file_path) print "Saved calibration file" return
# -*- coding: utf-8 -*- import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. ################# Recuperacion de productos utils.parameters['limit'] = 3 utils.getAnswer(utils.getUrl('fulfillment?'), requests.get)
import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. items = [] # Los markets pueden variar consulte la lista de markets disponibles en: # Markets may change see markets list at: # /api/markets items.append({'product_id': 162700, 'seller_sku': '7811X', 'stock': 1}) items.append({'product_id': 162700, 'seller_sku': '7911X', 'stock': 2}) items.append({'product_id': 162700, 'seller_sku': '8011X', 'stock': 4}) items.append({'product_id': 162700, 'seller_sku': '8111X', 'stock': 5}) items.append({'product_id': 162700, 'seller_sku': '1182X', 'stock': 6}) utils.getAnswer(utils.getUrl('stock?'), requests.put, items) # Verbo POST # Fecha a considerar el corte de inventario utils.init() data = {'update_stock': '2019-12-01T00:01:02'} utils.getAnswer(utils.getUrl('stock?'), requests.post, data)
def stereoCalibrate(self): print "If you calibrate from files, make sure stereo files are" print "in the left-right-left-right order" # Get settings & files self.stereo = True self.chooseCalibrationSettings() # Get patterns self.recordPatterns() # Compute the intrisic parameters first : rvecs = [np.zeros(3, dtype = np.float32) for i in xrange(self.max_frames_i)] tvecs = [np.zeros(3, dtype = np.float32) for i in xrange(self.max_frames_i)] # Call OpenCV routines to do the dirty work print "Computing intrisic parameters for the first camera" res = cv2.calibrateCamera(self.obj_points_l, self.img_points_l, self.frame_size, self.intrinsics_l, self.distorsion_l, rvecs, tvecs) rms, self.intrinsics_l, self.distorsion_l, rvecs, tvecs = res print "Computing intrisic parameters for the second camera" res = cv2.calibrateCamera(self.obj_points_r, self.img_points_r, self.frame_size, self.intrinsics_r, self.distorsion_r, rvecs, tvecs) rms, self.intrinsics_r, self.distorsion_r, rvecs, tvecs = res # Allocate arrays for the two camera matrix and distorsion matrices R = np.zeros((3, 3), dtype = np.float32) T = np.zeros((3, 1), dtype = np.float32) E = np.zeros((3, 3), dtype = np.float32) F = np.zeros((3, 3), dtype = np.float32) # Compute calibration parameters : print "Calibrating cameras.." print "Frame size : {}".format(self.frame_size) # set stereo flags stereo_flags = 0 # stereo_flags |= cv2.CALIB_FIX_INTRINSIC stereo_flags |= cv2.CALIB_USE_INTRINSIC_GUESS # Refine intrinsic parameters # stereo_flags |= cv2.CALIB_FIX_PRINCIPAL_POINT # Fix the principal points during the optimization. # stereo_flags |= cv2.CALIB_FIX_FOCAL_LENGTH # Fix focal length # stereo_flags |= cv2.CALIB_FIX_ASPECT_RATIO # fix aspect ratio stereo_flags |= cv2.CALIB_SAME_FOCAL_LENGTH # Use same focal length # stereo_flags |= cv2.CALIB_ZERO_TANGENT_DIST # Set tangential distortion to zero # stereo_flags |= cv2.CALIB_RATIONAL_MODEL # Use 8 param rational distortion model instead of 5 param plumb bob model res = cv2.stereoCalibrate(self.obj_points_l, self.img_points_l, self.img_points_r, self.frame_size, self.intrinsics_l, self.distorsion_l, self.intrinsics_r, self.distorsion_r) # flags=stereo_flags (rms, int_left, dist_left, int_right, dist_right, R, T, E, F) = res # Output print "Calibration done" print "Residual RMS : {}".format(rms) if (rms > 1.0): print "Calibration looks faulty, please re-run" print "\nCalibration parameters : \n Intrinsics -left \n {} \n\n Distorsion -left\n {}".format(\ int_left, dist_left) print "\nCalibration parameters : \n Intrinsics -right \n {} \n\n Distorsion -right\n {}".format(\ int_right, dist_right) print "\nRotation : \n{}\n".format(R) print "\nTranslation : \n{}\n".format(T) print "\nEssential matrix : \n{}\n".format(E) # Essential matrix print "\nFundamental matrix : \n{}\n".format(F) # Fundamental matrix # TODO : Compute perspective matrix ! # Save calibration parameters save_file = utils.getAnswer("Would you like to save the results ? (y/n) ", 'yn') b_write_success = False if save_file == "y" : while(b_write_success == False) : save_XML = utils.getAnswer("Save in XML format ? (y/n) ", "yn") filepath = raw_input("Where do you want to save the file ? (enter file path) ") try : if (save_XML) : file = utils.handlePath(filepath, "camera_calibration.xml") utils.saveParametersXML(int_left, dist_left, int_right, dist_right, R, T, self.frame_size, file) else : file_left = utils.handlePath(filepath, "_left.txt") utils.saveParameters(int_left, dist_left, R, T, file_left) file_right = utils.handlePath(filepath, "_right.txt") utils.saveParameters(int_right, dist_right, R, T, file_right) print "Parameters file written" b_write_success = True except : print "Wrong path, please correct" time.sleep(2) return
import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Put Publicar items = [] items.append({'product_id': 162699, 'market_id': 1}) # Claro items.append({'product_id': 162699, 'market_id': 2}) # Linio items.append({'product_id': 162699, 'market_id': 4}) # MeLi items.append({'product_id': 162699, 'market_id': 5}) # Walmart items.append({'product_id': 162699, 'market_id': 6}) # Amazon utils.getAnswer(utils.getUrl('productos/agotar?'), requests.put, data=items)
import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. import sys # Verbo GET utils.init() utils.getAnswer(utils.getUrl('ubicado?'), requests.get) # Verbo POST items = [] items.append({ 'ubicacion': 'INC-001', 'seller_sku': '0697-1000-0010', 'stock': 1 }) items.append({ 'ubicacion': 'INC-001', 'seller_sku': '0697-1000-0020', 'stock': 2 }) items.append({ 'ubicacion': 'INC-002', 'seller_sku': '0697-1000-0010', 'stock': 4 }) items.append({ 'ubicacion': 'INC-002', 'seller_sku': '0697-1000-0020', 'stock': 5 }) items.append({
import requests import utils # Review config.example file and rename it to config.py, do not forget to erase your keys. # Getting markets utils.getAnswer(utils.getUrl('markets?'), requests.get) # Posting market utils.init() # One market at a time market = {'market_id': 1, 'activo': 1, 'proteccion': 1} utils.getAnswer(utils.getUrl('markets?'), requests.post, market)
def _calibrate_stereo(self): print("-- If you calibrate from files, make sure stereo files are \n in the left-right-left-right order --") # Get settings & files self._choose_calibration_settings() # Get patterns self._record_patterns() # Compute the intrisic parameters first : rvecs = [np.zeros(3, dtype=np.float32) for _ in xrange(self.params.max_frames_i)] tvecs = [np.zeros(3, dtype=np.float32) for _ in xrange(self.params.max_frames_i)] self.intrinsics.append(np.zeros((4, 4), dtype=np.float32)) self.intrinsics.append(np.zeros((4, 4), dtype=np.float32)) self.distorsion.append(np.zeros(8, dtype=np.float32)) self.distorsion.append(np.zeros(8, dtype=np.float32)) # Call OpenCV routines to do the dirty work print("Computing intrisic parameters for the first camera") res = cv2.calibrateCamera(self.obj_points_l, self.img_points_l, self.frame_size, self.intrinsics[0], self.distorsion[0], rvecs, tvecs) rms, self.intrinsics[0], self.distorsion[0], rvecs, tvecs = res print("Computing intrisic parameters for the second camera") res = cv2.calibrateCamera(self.obj_points_r, self.img_points_r, self.frame_size, self.intrinsics[1], self.distorsion[1], rvecs, tvecs) rms, self.intrinsics[1], self.distorsion[1], rvecs, tvecs = res # Compute calibration parameters : print("Calibrating cameras.. \nFrame size : {}".format(self.frame_size)) # set stereo flags stereo_flags = 0 # stereo_flags |= cv2.CALIB_FIX_INTRINSIC stereo_flags |= cv2.CALIB_USE_INTRINSIC_GUESS # Refine intrinsic parameters # stereo_flags |= cv2.CALIB_FIX_PRINCIPAL_POINT # Fix the principal points during the optimization. # stereo_flags |= cv2.CALIB_FIX_FOCAL_LENGTH # Fix focal length # stereo_flags |= cv2.CALIB_FIX_ASPECT_RATIO # fix aspect ratio stereo_flags |= cv2.CALIB_SAME_FOCAL_LENGTH # Use same focal length # stereo_flags |= cv2.CALIB_ZERO_TANGENT_DIST # Set tangential distortion to zero # stereo_flags |= cv2.CALIB_RATIONAL_MODEL # Use 8 param rational distortion model instead of 5 param plumb bob model res = cv2.stereoCalibrate(self.obj_points_l, self.img_points_l, self.img_points_r, self.frame_size, self.intrinsics[0], self.distorsion[0], self.intrinsics[1], self.distorsion[1]) (rms, int_left, dist_left, int_right, dist_right, rotations, translations, essential, fundamental) = res # Output print "Calibration done. Residual RMS : {}".format(rms) if rms > 1.0: print "Calibration looks faulty, please re-run" print "\nCalibration parameters : \n Intrinsics -left \n {} \n\n Distorsion -left\n {}".format( int_left, dist_left) print "\nCalibration parameters : \n Intrinsics -right \n {} \n\n Distorsion -right\n {}".format( int_right, dist_right) print "\nRotation : \n{}\n".format(rotations) print "\nTranslation : \n{}\n".format(translations) print "\nEssential matrix : \n{}\n".format(essential) print "\nFundamental matrix : \n{}\n".format(fundamental) # Save calibration parameters save_file = utils.getAnswer("Would you like to save the results ? (y/n) ", 'yn') == 'y' b_write_success = False if save_file: while not b_write_success: filepath = raw_input("Where do you want to save the file ? (enter file path) ") try: file_left = utils.handlePath(filepath, "_overall.txt") self._json_save(rotations, translations, rms, file_left) print "Parameters file written" b_write_success = True except IOError: print "Wrong path, please correct" time.sleep(2) return
'market_id': 1, 'oferta': 101, 'precio': 201 }) # Claro items.append({ 'product_id': 163766, 'market_id': 2, 'oferta': 102, 'precio': 202 }) # Linio items.append({ 'product_id': 163766, 'market_id': 4, 'oferta': 104, 'precio': 204 }) # MeLi items.append({ 'product_id': 163766, 'market_id': 5, 'oferta': 105, 'precio': 205 }) # Walmart items.append({ 'product_id': 163766, 'market_id': 6, 'oferta': 106, 'precio': 206 }) # Amazon utils.getAnswer(utils.getUrl('precios?'), requests.put, items)
def _calibrate_mono(self): self._choose_calibration_settings() self._record_patterns() # Compute intrinsic parameters rvecs = [np.zeros(3) for _ in xrange(self.params.max_frames_i)] tvecs = [np.zeros(3) for _ in xrange(self.params.max_frames_i)] self.intrinsics.append(np.zeros((3, 3), dtype=np.float32)) self.distorsion.append(np.zeros(8, dtype=np.float32)) # Optimisation flags flags = 0 if self.params.focal_guess > 0.: self.intrinsics[0][0, 0] = self.params.focal_guess self.intrinsics[0][1, 1] = self.params.focal_guess self.intrinsics[0][0, 2] = self.frame_size[0]/2 self.intrinsics[0][1, 2] = self.frame_size[1]/2 self.intrinsics[0][2, 2] = 1. flags |= cv2.CALIB_USE_INTRINSIC_GUESS print("Using an initial intrisic matrix guess : \n {}".format( self.intrinsics[0])) # flags |= cv2.CALIB_FIX_INTRINSIC # flags |= cv2.CALIB_FIX_PRINCIPAL_POINT # flags |= cv2.CALIB_FIX_FOCAL_LENGTH # Fix focal length # flags |= cv2.CALIB_FIX_ASPECT_RATIO # fix aspect ratio # flags |= cv2.CALIB_ZERO_TANGENT_DIST # Set tangential distortion to zero # flags |= cv2.CALIB_RATIONAL_MODEL # Use 8 param rational distortion model instead of 5 param plumb bob model ret = cv2.calibrateCamera(np.array(self.obj_points).astype(np.float32), np.array(self.img_points).astype(np.float32), self.frame_size, self.intrinsics[0], self.distorsion[0], rvecs, tvecs, flags) [rms, self.intrinsics[0], self.distorsion[0], rvecs, tvecs] = ret print("Calibration done") print("\nResidual RMS (pixels): {}".format(rms)) print("\nCalibration parameters: Intrinsics \n {}".format(self.intrinsics[0])) print("\nDistorsion: \n {}".format(self.distorsion[0])) print("\nNumber of pictures used: {}".format(self.n_pattern_found)) # Save calibration parameters if not self.params.auto_save: b_write_success = False if utils.getAnswer("Save the results ? (y/n) ", 'yn') == "y": while not b_write_success: filepath = raw_input("Where do you want to save the file ?") filepath = utils.handlePath(filepath, "calib_results") try: self._json_save(rvecs, tvecs, rms, filepath + '.json') b_write_success = True except ValueError: print("Wrong path, please correct") else: calib_file_path = utils.handlePath(self.params.file_path, "calib_results") self._json_save(rvecs, tvecs, rms, calib_file_path + '.json') print("Saved calibration file") # Test the distorsion parameters: if utils.getAnswer("Would you like to test the distorsion parameters ? (y/n)", 'yn') == 'y': root_folder = os.path.dirname(self.pict_names[0]) dist_folder = os.path.join(root_folder, 'undistorted') if not os.path.exists(dist_folder): os.makedirs(dist_folder) for pict, name in zip(self.pictures, self.pict_names): undistorted = self._undistort_frame(pict) pict_name = os.path.basename(name) cv2.imwrite(os.path.join(dist_folder, pict_name[:-3] + 'undistorted.jpg'), undistorted) print("Image {} rectified".format(pict_name)) return