def img_callback(data): try: image = br.imgmsg_to_cv2(data,"bgr8") segm = cnt.segmentacao(image) cv2.imshow("seg",segm) cx,cy,seg = cnt.centroid(segm,image) cx = np.asarray(cx) cy = np.asarray(cy) _cx = 0 _cy = 0 if not cx is None and not cy is None: for k in range(len(cx)): _cx = (_cx+cx[k])/(k+1) _cy = (_cy+cy[k])/(k+1) cv2.circle(seg, (int(cx[k]), int(cy[k])), 7, (0,255,0), -1) cv2.circle(seg, (int(_cx), int(_cy)), 7, (0,255,0), -1) print _cy,_cx ''' if not cx is None and not cy is None: for k in range(cx): cv2.circle(image, (int(cx[k]), int(cy[k])), 7, (0,255,0), -1) ''' cv2.imshow("frame",seg) cv2.waitKey(1) except CvBridgeError, e: print e
def square_3(length, side): p1 = POLYGON.pos() POLYGON.backward(side) p2 = POLYGON.pos() POLYGON.left(90) POLYGON.forward(length) p3 = POLYGON.pos() POLYGON.right(90) POLYGON.forward(side) p4 = POLYGON.pos() vertex = (p1, p2, p3, p4) centro = centroid(vertex) sq = {'centro': centro, 'p1': p1, 'p2': p2, 'p3': p3, 'p4': p4} return sq
def square_3(LENGTH, SIDE): """To draw square type 3""" p1 = POLYGON.pos() POLYGON.backward(SIDE) p2 = POLYGON.pos() POLYGON.left(90) POLYGON.forward(LENGTH) p3 = POLYGON.pos() POLYGON.right(90) POLYGON.forward(SIDE) p4 = POLYGON.pos() vertex = (p1, p2, p3, p4) centro = centroid(vertex) sq = {'centro': centro, 'p1': p1, 'p2': p2, 'p3': p3, 'p4': p4} return sq
def align(filelist, coords=None, rad=None, aligned=False, manual=False): if len(filelist) < 2: raise Exception('At least 2 input images required') if not coords: h = pyfits.getheader(filelist[0]) coords = [int(h['XCEN']), int(h['YCEN'])] centers = [] if not aligned: # Centroid on all images print 'Centroiding...' for filename in filelist: center = centroid(filename, coords, rad, manual=manual) print center print '%s: (%.2f,%.2f)' % (filename, center[0], center[1]) centers.append(center) else: # Read centers for filename in filelist: h = pyfits.getheader(filename) centers.append([int(h['XCEN']), int(h['YCEN'])]) # Shift to center of first image centers = np.array(centers) shifts = centers - centers[0] if aligned: shifts = [(-x[1], -x[0]) for x in shifts] print print 'ref: %s (%.2f,%.2f)' % (filelist[0], centers[0][0], centers[0][1]) print newNames = [] for filename, shift in zip(filelist, shifts): if aligned: name_ext = '' else: name_ext = '.al' newName = imshift(filename, shift, centers[0], filelist[0], name_ext, clobber=True) newNames.append(newName) return zip(newNames, centers, shifts)
def square(side, length): POLYGON.forward(side) POLYGON.right(90) p1 = POLYGON.pos() POLYGON.forward(length) POLYGON.right(120) p2 = POLYGON.pos() POLYGON.forward(length) POLYGON.right(90) p3 = POLYGON.pos() POLYGON.forward(side) POLYGON.right(60) p4 = POLYGON.pos() vertex = (p1, p2, p3, p4) centro = centroid(vertex) #being called from centroid.py sq = {'centro': centro, 'p1': p1, 'p2': p2, 'p3': p3, 'p4': p4} return sq
def square(side, length): # number of each square side POLYGON.forward(side) POLYGON.right(90) p1 = POLYGON.pos() POLYGON.forward(length) POLYGON.right(120) p2 = POLYGON.pos() POLYGON.forward(length) POLYGON.right(90) p3 = POLYGON.pos() POLYGON.forward(side) POLYGON.right(60) p4 = POLYGON.pos() vertex = (p1, p2, p3, p4) centro = centroid(vertex) #being called from centroid.py sq = {'centro': centro, 'p1': p1, 'p2': p2, 'p3': p3, 'p4': p4} #print(f'centro {centro} p1 {p1} p2 {p2} p3 {p3} p4 {p4}') return sq
def square_3(l): p1 = polygon.pos() polygon.backward(10) p2 = polygon.pos() polygon.left(90) polygon.forward(l) p3 = polygon.pos() polygon.right(90) polygon.forward(10) p4 = polygon.pos() vertex = (p1, p2, p3, p4) centro = centroid(vertex) bp1 = turtle.Turtle() bp1.penup() bp1.setpos(centro) bp1.color("cyan") print(f'centro {centro} p1 {p1} p2 {p2} p3 {p3} p4 {p4}') return centro
def square(SIDE, LENGTH): """To draw square""" POLYGON.forward(SIDE) POLYGON.right(90) p1 = POLYGON.pos() POLYGON.forward(LENGTH) POLYGON.right(120) p2 = POLYGON.pos() POLYGON.forward(LENGTH) POLYGON.right(90) p3 = POLYGON.pos() POLYGON.forward(SIDE) POLYGON.right(60) p4 = POLYGON.pos() vertex = (p1, p2, p3, p4) centro = centroid(vertex) #being called from centroid.py sq = {'centro': centro, 'p1': p1, 'p2': p2, 'p3': p3, 'p4': p4} return sq
def align(filelist,coords=None,rad=None,aligned=False,manual=False): if len(filelist) < 2: raise Exception('At least 2 input images required') if not coords: h = pyfits.getheader(filelist[0]) coords = [int(h['XCEN']),int(h['YCEN'])] centers = [] if not aligned: # Centroid on all images print 'Centroiding...' for filename in filelist: center = centroid(filename,coords,rad,manual=manual) print center print '%s: (%.2f,%.2f)' % (filename,center[0],center[1]) centers.append(center) else: # Read centers for filename in filelist: h = pyfits.getheader(filename) centers.append([int(h['XCEN']),int(h['YCEN'])]) # Shift to center of first image centers = np.array(centers) shifts = centers-centers[0] if aligned: shifts = [(-x[1],-x[0]) for x in shifts] print print 'ref: %s (%.2f,%.2f)' % (filelist[0],centers[0][0],centers[0][1]) print newNames = [] for filename,shift in zip(filelist,shifts): if aligned: name_ext = '' else: name_ext = '.al' newName = imshift(filename,shift,centers[0],filelist[0],name_ext,clobber=True) newNames.append(newName) return zip(newNames,centers,shifts)
def square_3(length, side): # Number of each square side p1 = POLYGON.pos() POLYGON.backward(side) p2 = POLYGON.pos() POLYGON.left(90) POLYGON.forward(length) p3 = POLYGON.pos() POLYGON.right(90) POLYGON.forward(side) p4 = POLYGON.pos() vertex = (p1, p2, p3, p4) centro = centroid(vertex) """ bp1 = turtle.Turtle() bp1.penup() bp1.setpos(centro) bp1.color("cyan") """ sq = {'centro': centro, 'p1': p1, 'p2': p2, 'p3': p3, 'p4': p4} #print(f'centro {centro} p1 {p1} p2 {p2} p3 {p3} p4 {p4}') return sq
def main_loop(self): """ Single iteration of the application's main loop. """ # Get current image frame from the camera frame = self.camera.get_frame() self.h,self.w,_c= frame.shape self.current_centroid = centroid(np.sum(frame,2)/3) #display unaltered frame #imshow("Original",frame) #collect the output frame for display output_frame = process_image(frame,self.current_centroid,self.centroid_1,self.centroid_2,self.centroid_1_active,self.centroid_2_active) #show the processed/annotated output frame imshow("Processed",output_frame) #handle any key presses self.key_handler()
def global_distance_factor(coords): center = centroid(coords) r = [] n = len(coords) for i in range(n - 1): # the last point in coords is a duplicate, so skip it r.append(distance(center, coords[i])) r_max = max(r) # normalize values in r to the interval 0 to 1 for i in range(len(r)): r[i] = r[i] / r_max h_dist = [] # distance entropy e_dist = [] # quantization error j = 1 while 2 ** j <= n * 2: k = 2 ** j h = histogram(k, r, max(r)) h_dist.append(entropy(h, n - 1)) e_dist.append(quantization_error(h, n - 1)) j += 1 # Although Chen & Sundarum say there's a theoretical # maximum constant quantization error, it isn't specified. # Use the calculated maximum instead. e_max = max_quant_error(r) log2n = math.log(n - 1, 2) f_dist = [] # results of cost function for i in range(len(h_dist)): entropy_norm = h_dist[i] / log2n quant_err_norm = e_dist[i] / e_max f = entropy_norm + quant_err_norm f_dist.append(f) return min(f_dist)
import os, sys, json dirr = os.path.dirname(sys.argv[0]) filename = os.path.join(dirr, '../../libraries') sys.path.append(filename) dirr = os.path.dirname(sys.argv[0]) filename = os.path.join(dirr, '../imageProcess') sys.path.append(filename) import preprocessing, proportion, centroid dirr = os.path.dirname(sys.argv[0]) filename = os.path.join(dirr, '../../../img/generated_canvas/verify_11.png') img = preprocessing.preprocessing(filename) proportion = proportion.proportion(img) centroidX = centroid.centroid(img)[0] centroidY = centroid.centroid(img)[1] result = { 'prop' : proportion, 'centX' : centroidX, 'centY' : centroidY, } print json.dumps(result)
def main(): preprocessing = False calculateConstant_x = 300 calculateConstant_y = 615 personLabelID = 15.00 debug = True accuracyThreshold = 0.4 RED = (0, 0, 255) YELLOW = (0, 255, 255) GREEN = (0, 255, 0) BLACK = (0, 0, 0) write_video = False if __name__ == "__main__": caffeNetwork = cv2.dnn.readNetFromCaffe("./SSD_MobileNet_prototxt.txt", "./SSD_MobileNet.caffemodel") cap = cv2.VideoCapture(0) # cap = cv2.VideoCapture("./vp.mp4") fourcc = cv2.VideoWriter_fourcc(*"XVID") # output_movie = cv2.VideoWriter("./result.avi", fourcc, 24, (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))) while cap.isOpened(): debug_frame, frame = cap.read() highRisk = set() mediumRisk = set() position = dict() detectionCoordinates = dict() if not debug_frame: # print("Video Error Gaes") break if preprocessing: frame = CLAHE(frame) print(frame) (imageHeight, imageWidth) = frame.shape[:2] pDetection = cv2.dnn.blobFromImage( cv2.resize(frame, (imageWidth, imageHeight)), 0.007843, (imageWidth, imageHeight), 127.5) caffeNetwork.setInput(pDetection) detections = caffeNetwork.forward() for i in range(detections.shape[2]): accuracy = detections[0, 0, i, 2] if accuracy > accuracyThreshold: idOfClasses = int(detections[0, 0, i, 1]) box = detections[0, 0, i, 3:7] * np.array( [imageWidth, imageHeight, imageWidth, imageHeight]) (startX, startY, endX, endY) = box.astype('int') if idOfClasses == personLabelID: boundBoxDefaultColor = (255, 255, 255) cv2.rectangle(frame, (startX, startY), (endX, endY), boundBoxDefaultColor, 2) detectionCoordinates[i] = (startX, startY, endX, endY) centroid_x, centroid_y, boundBoxHeight = centroid( startX, endX, startY, endY) distance = calcDistance(boundBoxHeight) centroid_x_centimeters = ( centroid_x * distance) / calculateConstant_y centroid_y_centimeters = ( centroid_y * distance) / calculateConstant_y position[i] = (centroid_x_centimeters, centroid_y_centimeters, distance) for i in position.keys(): for j in position.keys(): if i < j: distanceOfboundBoxes = sqrt( pow(position[i][0] - position[j][0], 2) + pow(position[i][1] - position[j][1], 2) + pow(position[i][2] - position[j][2], 2)) if distanceOfboundBoxes < 150: # jarak tidak aman highRisk.add(i), highRisk.add(j) elif distanceOfboundBoxes < 200 > 150: # Jarak rawan mediumRisk.add(i), mediumRisk.add(j) cv2.putText(frame, "Sangat Rawan Penularan : " + str(len(highRisk)), (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) cv2.putText(frame, "Rawan Penularan : " + str(len(mediumRisk)), (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 2) cv2.putText( frame, "Jumlah Terdeteksi : " + str(len(detectionCoordinates)), (20, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) drawResult(frame, position) if write_video: output_movie.write(frame) cv2.imshow('Dashboard Satpam', frame) waitkey = cv2.waitKey(1) if waitkey == ord("q"): break
POLYGON.backward(side) POLYGON.left(90) POLYGON.begin_fill() p1 = POLYGON.pos() POLYGON.forward(length_3 / 3) p2 = POLYGON.pos() POLYGON.right(120) POLYGON.forward(length_3 / 3) p3 = POLYGON.pos() POLYGON.right(90) POLYGON.forward(side) p4 = POLYGON.pos() vertex = (p1, p2, p3, p4) centro = centroid(vertex) alternate_color_1(i) sq = {'centro': centro, 'p1': p1, 'p2': p2, 'p3': p3, 'p4': p4} POLYGON.end_fill() COUNT += 1 if i % 2 != 0: square_dict[naming[i][1][2] + naming[i][0][2]] = sq else: square_dict[naming[i][0][2] + naming[i][1][2]] = sq POLYGON.begin_fill() sq = square_3(length_3 / 3, side) alternate_color_2(i) POLYGON.end_fill()
def subtract(flux1, time1, cadence, q, factor, cfilepath, centroid_type, cutoutdims, cluster, isolation): workingdir = os.getcwd() if centroid_type == 'e': os.chdir(cfilepath) centroids = np.loadtxt(f'{cluster}q{q}centroid.dat', delimiter=',') os.chdir(workingdir) x_shifts = centroids[:, 0] y_shifts = centroids[:, 1] # make mask first before cutting down flux mask = gaussmask(factor, flux1.shape[1], flux1.shape[2], isolation) # cut down both mask and flux, i.e. get rid of zeros flux1, mask = zerocutter(flux1, mask, factor) # prepare arrays/get dimensions etc if centroid_type == 'e': fluxnew, timenew, x_shifts, y_shifts = nc.nancleaner3d_c( flux1, time1, x_shifts, y_shifts) elif centroid_type == 't': fluxnew, timenew = nc.nancleaner3d(flux1, time1) dump, newcadence = nc.nancleaner3d(flux1, cadence) timespan = fluxnew.shape[0] # regridding oldy, oldx = fluxnew.shape[1], fluxnew.shape[2] # reset dims newy, newx = fluxnew.shape[1] * factor, fluxnew.shape[2] * factor re_flux = np.zeros((timespan, newy, newx)) shifted = np.zeros((timespan, newy, newx)) nanmask = np.asarray(np.where(np.isnan(fluxnew) == True)) rg_nanmask = np.array( (nanmask[0], nanmask[1] * factor, nanmask[2] * factor)) for i in range(timespan): interpolant = spi.RectBivariateSpline(np.arange(oldy), np.arange(oldx), np.nan_to_num(fluxnew[i]), kx=1, ky=1) re_flux[i] = interpolant(np.linspace(0, oldy - 1, newy), np.linspace(0, oldx - 1, newx)) #/ (factor*factor) # regridding base cutout for plotting (oy vey) avg_original = np.nanmean(fluxnew, axis=0) regridded_base = rg.regrid(avg_original, factor) # centroiding originalmask = np.zeros(flux1[0].shape) #+3 originalmask[cutoutdims - 2:cutoutdims + 1, cutoutdims - 2:cutoutdims + 1] += 3 # 3x3 box for checking mask_rg = rg.regrid_slow(originalmask, factor) if centroid_type == 't': x_cent, y_cent = ct.centroid(timespan, re_flux, mask_rg) midx, midy = (newx - 1) / 2, (newy - 1) / 2 x_shifts = (x_cent - midx) y_shifts = (y_cent - midy) elif centroid_type == 'e': x_cent = 0 y_cent = 0 for i in range(timespan): interpolant = spi.RectBivariateSpline(np.arange(newy), np.arange(newx), re_flux[i, :, :], kx=1, ky=1) # interpolant = spi.interp2d(np.arange(newy), np.arange(newx), re_flux[i,:,:], kind='cubic') shifted[i, :, :] = interpolant( np.linspace(0 - y_shifts[i], newy - y_shifts[i], newy), np.linspace(0 - x_shifts[i], newx - x_shifts[i], newx)) avgshift = np.nanmean(shifted, axis=0) # mask making maskrange = np.nanmax(avgshift) - np.nanmin(avgshift) # maskmax = np.nanmax(avgshift) - 0.5 * maskrange maskmin = np.nanmin(avgshift) + 0.05 * maskrange # cut for background # defining six different standard masks # maskarr = np.zeros((6,newy,newx)) # maskarr[0][(cutoutdims-1)*factor:cutoutdims*factor,(cutoutdims-1)*factor:cutoutdims*factor] +=1 # maskarr[1][(cutoutdims-2)*factor:(cutoutdims+1)*factor,(cutoutdims-1)*factor:cutoutdims*factor] += 1 # maskarr[1][(cutoutdims-1)*factor:cutoutdims*factor,(cutoutdims-2)*factor:(cutoutdims-1)*factor] += 1 # maskarr[1][(cutoutdims-1)*factor:cutoutdims*factor,cutoutdims*factor:(cutoutdims+1)*factor] += 1 # maskarr[2] += 1 # maskarr[3] += circle(9, factor, oldy, oldx) # maskarr[4] += circle(5, factor, oldy, oldx) # maskarr[5] += circle(3, factor, oldy, oldx) # if mask != None: # maskarr = np.delete(maskarr, np.delete(np.arange(6), mask), axis=0) # annulus mask_bg = np.zeros((newy, newx)) counter = 0 for index, val in np.ndenumerate(avgshift): if avgshift[index] < maskmin: # and np.isnan(avgshift[index]) == False: mask_bg[index] = -1 counter += 1 # calculating background lclength = len(timenew) for j in range(lclength): bg = np.nansum(shifted[j][np.where(mask_bg == -1)]) bg /= counter shifted[j] -= bg avgflux = np.nanmean(shifted, axis=0) # new average image after output = np.c_[newcadence, timenew] new_flux = np.zeros(lclength) ap_av = np.nansum(avgflux * mask) for j in range(lclength): placeholder = shifted[j] - avgflux aperture = np.nansum(placeholder * mask) # annulus = sum(placeholder[np.where(mask==-1)]) # annulus /= counter new_flux[j] = aperture + ap_av #- annulus output = np.c_[output, new_flux] # for deprecated version with multiple masks: # for i in range(maskarr.shape[0]): # new_flux = np.zeros(lclength) # ap_av = np.nansum(avgflux[np.where(maskarr[i]==1)]) # for j in range(lclength): # placeholder = shifted[j] - avgflux # aperture = np.nansum(placeholder[np.where(maskarr[i]==1)]) # # annulus = sum(placeholder[np.where(mask==-1)]) # # annulus /= counter # new_flux[j] = aperture + ap_av #- annulus # output = np.c_[output, new_flux] return output, mask, avgflux, regridded_base, x_cent, y_cent # prev maskarr
def __init__(self): # Manually set up our ROI for grabbing the hand. # Feel free to change these. I just chose the top right corner for filming. roi_top = 20 roi_bottom = 140 roi_right = 260 roi_left = 380 # ROI 2 roi_top2 = 340 roi_bottom2 = 460 cam = cv2.VideoCapture(0) cam.set(3, 640) cam.set(4, 480) # Intialize a frame count num_frames = 0 # background calc in real time # Start with a halfway point between 0 and 1 of accumulated weight accumulated_weight = 0.7 accumulated_weight2 = 0.7 accumulated_weight3 = 0.7 background_calc = calc_accum() while True: # get the current frame ret, frame = cam.read() # flip the frame so that it is not the mirror view frame = cv2.flip(frame, 1) # clone the frame frame_copy = frame.copy() # object detection. height = frame_copy.shape[0] object_roi_top = height / 2 object_roi_bottom = 640 object_detect = frame[object_roi_top:object_roi_bottom, :] object_gray = cv2.cvtColor(object_detect, cv2.COLOR_BGR2GRAY) object_gray = cv2.GaussianBlur(object_gray, (5, 5), 0) # ROI 1 # Grab the ROI from the frame(1) roi = frame[roi_top:roi_bottom, roi_right:roi_left] gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY) # Apply grayscale and blur to ROI gray = cv2.GaussianBlur(gray, (5, 5), 0) # ROI 2 roi2 = frame[roi_top2:roi_bottom2, roi_right:roi_left] gray2 = cv2.cvtColor(roi2, cv2.COLOR_BGR2GRAY) gray2 = cv2.GaussianBlur(gray2, (5, 5), 0) # For the first 60 frames we will calculate the average of the background. if num_frames < 60: background_calc.calc_accum_avg(gray, accumulated_weight) background_calc.calc_accum_avg2(gray2, accumulated_weight2) background_calc.calc_accum_avg3(object_gray, accumulated_weight3) if num_frames <= 59: cv2.putText(frame_copy, "WAIT! GETTING BACKGROUND AVG.", (1, 470), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1) cv2.imshow("Vision", frame_copy) else: # shape detect upper upper_shape = segment(gray) if upper_shape is not None: upper_thresh, upper_contour, upper_segment, upper_cnts = upper_shape upper_shape_detect = detect(upper_contour) # Apply hough transform on the image (upper_cX, upper_cY, upper_c) = centroid(upper_cnts) cv2.drawContours(frame_copy, [upper_segment + (roi_right, roi_top)], -1, (255, 0, 0), 1) cv2.circle(frame_copy, (upper_cX + roi_right, roi_top + upper_cY), 7, (255, 0, 0), -1) cv2.putText(frame_copy, "upper_shape : " + str(upper_shape_detect), (1, 440), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1) cv2.imshow("upper_threshold", upper_thresh) # shape detect bottom bottom_shape = segment(gray2) if bottom_shape is not None: bottom_thresh, bottom_contour, bottom_segment, bottom_cnts = bottom_shape bottom_shape_detect = detect(bottom_contour) (bottom_cX, bottom_cY, bottom_c) = centroid(bottom_cnts) cv2.drawContours(frame_copy, [bottom_segment + (roi_right, roi_top2)], -1, (255, 0, 0), 1) cv2.putText(frame_copy, "bottom_shape : " + str(bottom_shape_detect), (1, 460), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1) cv2.circle(frame_copy, (bottom_cX + roi_right, roi_top2 + bottom_cY), 7, (255, 0, 0), -1) cv2.imshow("bottom_threshold", bottom_thresh) # distance upper_c = (upper_cX + roi_right, roi_top + upper_cY) bottom_c = (bottom_cX + roi_right, roi_top2 + bottom_cY) roi_distance = distance(upper_c, bottom_c) cv2.putText(frame_copy, "ROI DISTANCE={} ".format(roi_distance), (1, 400), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1) if upper_shape_detect == "square" or "rectangle" and bottom_shape_detect == "square" or "rectangle": angles = rotation(bottom_c, upper_c) cv2.putText(frame_copy, "difference ={}".format(angles), (1, 420), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1) object_detect = segment(object_gray) if object_detect is not None: object_thresh, object_contour, object_segment, object_cnts = object_detect multi_obejct_detect = multi_detect() multi_obejct_detect.detect( frame_copy[object_roi_top:object_roi_bottom, :], object_contour) # Draw ROI Rectangle on frame copy cv2.rectangle(frame_copy, (roi_left, roi_top), (roi_right, roi_bottom), (0, 0, 255), 5) cv2.rectangle(frame_copy, (roi_left, roi_top2), (roi_right, roi_bottom2), (0, 0, 255), 5) # increment the number of frames for tracking num_frames += 1 #print(distance(upper_c,bottom_c)) # Display the frame with segmented hand cv2.imshow("Vision", frame_copy) # Close windows with Esc k = cv2.waitKey(1) & 0xFF if k == 27: break cam.release() cv2.destroyAllWindows()
Rx, Ry = Bezier(list(zip(Rxc, Ryc))).T RunningVolume = RunningVolume - RimSubtract(Rx, Ry) for i in range(0, len(Cdata)): Cxc = np.append(Cxc, Cdata[i, 0]) Cyc = np.append(Cyc, Cdata[i, 1]) Cx, Cy = Bezier(list(zip(Cxc, Cyc))).T RunningVolume = RunningVolume - CupSubtract(Cx, Cy) density = Sdata[7] / (10**(9)) halfmass = RunningVolume * density * (10**3) # This populates matrices for plotting megamatx, megamaty, prof, rim, cup, bulkmat = Bulkmat(Px, Py, Rx, Ry, Cx, Cy, Bdata, Pdata, Rdata, Cdata) #Creates coordinate pair that makes up physical location of centroid of #... 2d quarter section, and computes RimWeightRatio Cx, Cy, RimWeightRatio = centroid(bulkmat) # CHECKING MINIMUM WALL THICKNESS AGAINST SPECIFIED ALLOWABLE MINIMUM floatingminthick = minthick(Bdata, Sdata, prof, rim, cup) thick_criteria = Sdata[8] #this is in millimeters # ERROR CHECKING OCCURS IN THIS SECTION # IF AN ERROR OCCURS, THEN THE BREAKFLAG, HEREFORTH SET EQUAL TO ZERO, # ... WILL BE SET EQUAL TO A NON-ZERO VALUE thickflag = 0 if floatingminthick <= thick_criteria: thickflag = 1 print("ERRROR: YOUR DESIGN VIOLATES MINIMUM WALL THICKNESS") print("THIS CAN EITHER BE DUE TO SELF INTERSECTION, OR A GENUINELY") print("TOO THIN WALL.") #Yeah, this ain't workin, yet. farea = fracturearea(floatingminthick, thick_criteria, Sdata, prof, rim, cup)
times = json.loads(sys.argv[1]) NUMDEVS = 3 imgArray = ['filename_1.png', 'filename_2.png', 'filename_3.png', 'filename_4.png', 'filename_5.png', 'filename_6.png', 'filename_7.png', 'filename_8.png', 'filename_9.png', 'filename_10.png'] dirr = os.path.dirname(sys.argv[0]) filename = os.path.abspath(os.path.join(dirr, '../../../img/generated_canvas')) centroidsX = [] centroidsY = [] proportions = [] for img in imgArray: fileTemp = os.path.join(filename, img) imgTemp = preprocessing.preprocessing(fileTemp) imgTemp.save('fart.png') proportions.append(proportion.proportion(imgTemp)) centroidsX.append(centroid.centroid(imgTemp)[0]) centroidsY.append(centroid.centroid(imgTemp)[1]) meanProps, devProps = meanStDev.meanStDev(proportions) meanCentsX, devCentsX = meanStDev.meanStDev(centroidsX) meanCentsY, devCentsY = meanStDev.meanStDev(centroidsY) meanTimes, devTimes = meanStDev.meanStDev(times) minProps = meanProps - (NUMDEVS * devProps) maxProps = meanProps + (NUMDEVS * devProps) resultsProps = [minProps, maxProps] minCentsX = meanCentsX - (NUMDEVS * devCentsX) maxCentsX = meanCentsX + (NUMDEVS * devCentsX) resultsCentsX = [minCentsX, maxCentsX]