def _get_blr_to_jib(self): point_l = self.gantry.crane.bottom_left() point_r = self.gantry.crane.bottom_right() angle = self.jib.jib.angle # result = Point(0, 0), Point(-10000, -10000) result = None if angle > radians(0) and angle < radians(180): result1 = None result2 = None # remove code repetition if angle > radians(0) and angle < radians(90): raw_result = self._get_perpendicular_bottom_angle_to_jib( point_r) if raw_result[1].x >= self.jib.jib.point_1.x and raw_result[ 1].x <= self.jib.jib.get_two_point().x: result1 = raw_result raw_result = self._get_perpendicular_bottom_angle_to_jib( point_l) if raw_result[1].x >= self.jib.jib.point_1.x and raw_result[ 1].x <= self.jib.jib.get_two_point().x: result2 = raw_result else: raw_result = self._get_perpendicular_bottom_angle_to_jib( point_r) if raw_result[1].x <= self.jib.jib.point_1.x and raw_result[ 1].x >= self.jib.jib.get_two_point().x: result1 = raw_result raw_result = self._get_perpendicular_bottom_angle_to_jib( point_l) if raw_result[1].x <= self.jib.jib.point_1.x and raw_result[ 1].x >= self.jib.jib.get_two_point().x: result2 = raw_result if result1 and result2: result1_length = length(result1) result2_length = length(result2) if result1_length < result2_length: result = result1 else: result = result2 elif result1: result = result1 elif result2: result = result2 if self.debug: if result: self._update_render_for_line(self.line[0], result[0], result[1]) else: self._update_render_for_line(self.line[0], Point(-1, -1), Point(-2, -2)) return result
def _get_jib_to_angle_blr(self): point_bl = self.gantry.crane.bottom_left() point_br = self.gantry.crane.bottom_right() result = Point(0, 0), Point(-10000, -10000) result1 = self._get_length_jib_bottom_angle(point_bl) result2 = self._get_length_jib_bottom_angle(point_br) result1_length = length(result1) result2_length = length(result2) if result1_length < result2_length: result = result1 else: result = result2 if self.debug and result: self._update_render_for_line(self.line[6], result[0], result[1]) return result
def decision_making(self): """ Here all base logic. FIX """ length_distances = [] is_warnings = False blr_to_jib = self._get_blr_to_jib() if blr_to_jib: real_length = length(blr_to_jib) length_distances.append(real_length) is_include_warning = self._decision_for_blr_to_jib(real_length) if is_include_warning: is_warnings = True # analyse for vertical jib_to_lr = self._get_jib_to_left_right() if jib_to_lr: real_length = length(jib_to_lr) length_distances.append(real_length) is_include_warning = self._decision_for_jib_to_lr(real_length) if is_include_warning: is_warnings = True jib_to_b = self._get_jib_to_bottom() if jib_to_b: real_length = length(jib_to_b) length_distances.append(real_length) is_include_warning = self._decision_for_jib_to_b(real_length) if is_include_warning: is_warnings = True jib_to_angle_bl = self._get_jib_to_angle_blr() if jib_to_angle_bl: real_length = length(jib_to_angle_bl) length_distances.append(real_length) distance = min(length_distances) self.distance = int(round(distance, 0)) if not is_warnings: self.desired_gantry_crane_block = 'None' self.desired_jib_crane_block = 'None' self.desired_jib_block = 'None' self.desired_gantry_danger = False self.desired_jib_danger = False self.desired_gantry_warning = False self.desired_jib_warning = False
def find_salt_bridges(self, cutoff=8.0): """Find all salt bridges in the protein """ SBs = [] self.get_titratable_groups() for res1 in self.titratable_groups.keys(): r1_cens = self.calculate_titgroup_center(res1) for group1 in r1_cens[res1].keys(): group1_ID = '%s:%s' % (res1, group1) for res2 in self.titratable_groups.keys(): r2_cens = self.calculate_titgroup_center(res2) for group2 in r2_cens[res2].keys(): group2_ID = '%s:%s' % (res2, group2) if group1_ID != group2_ID: if self.titgroups[group1][ 'charge'] * self.titgroups[group2][ 'charge'] == -1: import geometry dist = geometry.length(r1_cens[res1][group1] - r2_cens[res2][group2]) if dist <= cutoff: SBs.append([group1_ID, group2_ID, dist]) # # Done # return SBs
def calculate_burning_perimeter(regression_map, regression_depth, map_ratio, fidelity): contours = measure.find_contours(regression_map, regression_depth, fully_connected='low') perimeter = 0 for contour in contours: perimeter += (geometry.length(contour, fidelity)) * map_ratio return perimeter
def getCorePerimeter(self, regDist): mapDist = self.normalize(regDist) corePerimeter = 0 contours = measure.find_contours(self.regressionMap, mapDist, fully_connected='low') for contour in contours: corePerimeter += self.mapToLength( geometry.length(contour, self.mapDim)) return corePerimeter
def drawArrow(self, painter, p, v, head_size): base = p-v tip = p+v painter.drawLine(base, tip) vl = length(v) nv = v / vl head_size = head_size * vl orth = QPointF(nv.y(), -nv.x())*head_size base_center = tip-nv*head_size*2.0 base1 = base_center + orth base2 = base_center - orth base_center = tip-nv*head_size*1.0 painter.drawPolygon(QPolygonF([base_center, base1, tip, base2]))
def drawArrow(self, painter, p, v, head_size): base = p - v tip = p + v painter.drawLine(base, tip) vl = length(v) nv = v / vl head_size = head_size * vl orth = QPointF(nv.y(), -nv.x()) * head_size base_center = tip - nv * head_size * 2.0 base1 = base_center + orth base2 = base_center - orth base_center = tip - nv * head_size * 1.0 painter.drawPolygon(QPolygonF([base_center, base1, tip, base2]))
def __init__(self, result, result_type, forward=True): QObject.__init__(self) self.result = result self.result_type = result_type if result_type == "Data": self.data = result self.image_list = result.images_name if forward: self.images = result.images_name[:-1] else: self.images = result.images_name[1:] self.forward = forward else: self.data = result.data self.image_list = result.images_used self.images = result.images self.forward = (self.image_list[0] == self.images[0]) # Find maximum velocity image_list = self.image_list data = self.data max_v = 0 for i, image_id in enumerate(image_list[:-1]): next_image_id = image_list[i + 1] d1 = data[image_id] d2 = data[next_image_id] dt = d2.time - d1.time for pt_id in d1: if pt_id in d2: v = (d2[pt_id] - d1[pt_id]) / dt vl = length(v) if vl > max_v: max_v = vl self.max_velocity = max_v self.factor = 0.5 params = parameters.instance self.color = params.arrow_color self.head_size = params.arrow_head_size self.line_width = self.data.minScale() * params.arrow_line_size
def __init__(self, result, result_type, forward=True): QObject.__init__(self) self.result = result self.result_type = result_type if result_type == "Data": self.data = result self.image_list = result.images_name if forward: self.images = result.images_name[:-1] else: self.images = result.images_name[1:] self.forward = forward else: self.data = result.data self.image_list = result.images_used self.images = result.images self.forward = (self.image_list[0] == self.images[0]) # Find maximum velocity image_list = self.image_list data = self.data max_v = 0 for i, image_id in enumerate(image_list[:-1]): next_image_id = image_list[i+1] d1 = data[image_id] d2 = data[next_image_id] dt = d2.time - d1.time for pt_id in d1: if pt_id in d2: v = (d2[pt_id] - d1[pt_id]) / dt vl = length(v) if vl > max_v: max_v = vl self.max_velocity = max_v self.factor = 0.5 params = parameters.instance self.color = params.arrow_color self.head_size = params.arrow_head_size self.line_width = self.data.minScale()*params.arrow_line_size
def find_salt_bridges(self,cutoff=8.0): """Find all salt bridges in the protein """ SBs=[] self.get_titratable_groups() for res1 in self.titratable_groups.keys(): r1_cens=self.calculate_titgroup_center(res1) for group1 in r1_cens[res1].keys(): group1_ID='%s:%s' %(res1,group1) for res2 in self.titratable_groups.keys(): r2_cens=self.calculate_titgroup_center(res2) for group2 in r2_cens[res2].keys(): group2_ID='%s:%s' %(res2,group2) if group1_ID!=group2_ID: if self.titgroups[group1]['charge']*self.titgroups[group2]['charge']==-1: import geometry dist=geometry.length(r1_cens[res1][group1]-r2_cens[res2][group2]) if dist<=cutoff: SBs.append([group1_ID,group2_ID,dist]) # # Done # return SBs
def __call__(self, painter, imageid): if imageid == len(self.images): return head_size = self.head_size color = self.color line_width = self.line_width max_velocity = self.max_velocity img1 = self.image_list[imageid] img2 = self.image_list[imageid + 1] d1 = self.data[img1] d2 = self.data[img2] dt = d2.time - d1.time pen = QPen(color) pen.setWidthF(line_width) brush = QBrush(color) painter.setPen(pen) painter.setBrush(brush) for pt_id in d1: if pt_id in d2: p = d1[pt_id] if self.forward else d2[pt_id] v = (d2[pt_id] - d1[pt_id]) / dt * self.factor vl = length(v) if abs(vl / max_velocity) > 1e-3: self.drawArrow(painter, p, v, head_size)
def getRegressionData(self, mapDim, numContours=15, coreBlack=True): self.initGeometry(mapDim) self.generateCoreMap() masked = np.ma.MaskedArray(self.coreMap, self.mask) regressionMap = None contours = [] contourLengths = {} try: self.generateRegressionMap() regmax = np.amax(self.regressionMap) regressionMap = self.regressionMap[:, :].copy() if coreBlack: regressionMap[np.where( self.coreMap == 0)] = regmax # Make the core black regressionMap = np.ma.MaskedArray(regressionMap, self.mask) for dist in np.linspace(0, regmax, numContours): contours.append([]) contourLengths[dist] = 0 layerContours = measure.find_contours(self.regressionMap, dist, fully_connected='low') for contour in layerContours: contours[-1].append(geometry.clean(contour, self.mapDim, 3)) contourLengths[dist] += geometry.length( contour, self.mapDim) except ValueError as exc: # If there aren't any contours, do nothing print(exc) return (masked, regressionMap, contours, contourLengths)
def __call__(self, painter, imageid): if imageid == len(self.images): return head_size = self.head_size color = self.color line_width = self.line_width max_velocity = self.max_velocity img1 = self.image_list[imageid] img2 = self.image_list[imageid+1] d1 = self.data[img1] d2 = self.data[img2] dt = d2.time - d1.time pen = QPen(color) pen.setWidthF(line_width) brush = QBrush(color) painter.setPen(pen) painter.setBrush(brush) for pt_id in d1: if pt_id in d2: p = d1[pt_id] if self.forward else d2[pt_id] v = (d2[pt_id] - d1[pt_id]) / dt * self.factor vl = length(v) if abs(vl / max_velocity) > 1e-3: self.drawArrow(painter, p, v, head_size)
def calculate_matrix(self,filename=None,eps=8,exdi=80,updater=None): """ # This function calculates a simplified version of the charge-charge interaction # energy matrix # # # Calculate the factor that converts formal charges and distances in A into kT energies # eps is the dielectric constant """ factor=(1.0/(4.0*pi*e0))*(e*e/A)*1.0/eps*1.0/(k*T) # # Get the fast scaled accessibility # acc=self.get_atoms_around(updater=updater) # # And now we calculate the matrix # import string if not getattr(self,'titratable_groups',None): self.get_titratable_groups() self.matrix={} self.distmatrix={} titgrps=self.titratable_groups residues=titgrps.keys() residues.sort() # # Get the total number of calcs # ncalcs=len(residues)*len(residues) count=0 for residue in residues: for group in titgrps[residue]: name1=self.get_titgroup_name(residue,group) if not self.matrix.has_key(name1): self.matrix[name1]={} if not self.distmatrix.has_key(name1): self.distmatrix[name1]={} # # Calculate distance from center of atoms # x=0.0 y=0.0 z=0.0 for atom in group['atoms']: x=x+self.atoms[residue+':'+atom]['X']/float(len(group['atoms'])) y=y+self.atoms[residue+':'+atom]['Y']/float(len(group['atoms'])) z=z+self.atoms[residue+':'+atom]['Z']/float(len(group['atoms'])) # # Now for the second residue # for residue2 in titgrps.keys(): for group2 in titgrps[residue2]: if not updater is None: updater('%d of %d (%4.1f%% completed)' %(count,ncalcs,float(count)/float(ncalcs)*100.0)) count=count+1 name2=self.get_titgroup_name(residue2,group2) if self.matrix[name1].has_key(name2): continue # # Get center of atoms for this res # x2=0.0 y2=0.0 z2=0.0 for atom in group2['atoms']: x2=x2+self.atoms[residue2+':'+atom]['X']/float(len(group2['atoms'])) y2=y2+self.atoms[residue2+':'+atom]['Y']/float(len(group2['atoms'])) z2=z2+self.atoms[residue2+':'+atom]['Z']/float(len(group2['atoms'])) # # Get the distance # v1=numpy.array([x,y,z]) v2=numpy.array([x2,y2,z2]) import geometry dist=geometry.length(v1-v2) if dist!=0: crg1=group['charge'] crg2=group2['charge'] ene=factor*float(crg1*crg2)/(math.pow(dist,1.5)) # # Get the influence of the acc # acc_frac=math.sqrt(acc[name1]*acc[name2]) acc_frac=math.pow(acc_frac,2.0) ene=ene*1.99*acc_frac+(1.0-acc_frac)*float(eps)/float(exdi)*ene else: ene=0.0 #if ene: # print '%20s - %20s: %7.3f' %(name1,name2,ene) self.matrix[name1][name2]=[ene,0.0,0.0,0.0] self.distmatrix[name1][name2]=dist if not self.matrix.has_key(name2): self.matrix[name2]={} self.matrix[name2]={} self.matrix[name2][name1]=[ene,0.0,0.0,0.0] self.distmatrix[name2][name1]=dist # # Write the matrix file # if filename: import pKaIO X=pKaIO.pKaIO() X.matrix=self.matrix X.write_matrix(filename+'.MATRIX.DAT') return self.matrix
def device_pixels(cr, x): x = float(x) px,py = cr.device_to_user_distance(x,0.); return geometry.length(px,py)
def calculate_matrix(self, filename=None, eps=8, exdi=80, updater=None): """ # This function calculates a simplified version of the charge-charge interaction # energy matrix # # # Calculate the factor that converts formal charges and distances in A into kT energies # eps is the dielectric constant """ factor = (1.0 / (4.0 * pi * e0)) * (e * e / A) * 1.0 / eps * 1.0 / (k * T) # # Get the fast scaled accessibility # acc = self.get_atoms_around(updater=updater) # # And now we calculate the matrix # import string if not getattr(self, 'titratable_groups', None): self.get_titratable_groups() self.matrix = {} self.distmatrix = {} titgrps = self.titratable_groups residues = titgrps.keys() residues.sort() # # Get the total number of calcs # ncalcs = len(residues) * len(residues) count = 0 for residue in residues: for group in titgrps[residue]: name1 = self.get_titgroup_name(residue, group) if not self.matrix.has_key(name1): self.matrix[name1] = {} if not self.distmatrix.has_key(name1): self.distmatrix[name1] = {} # # Calculate distance from center of atoms # x = 0.0 y = 0.0 z = 0.0 for atom in group['atoms']: x = x + self.atoms[residue + ':' + atom]['X'] / float( len(group['atoms'])) y = y + self.atoms[residue + ':' + atom]['Y'] / float( len(group['atoms'])) z = z + self.atoms[residue + ':' + atom]['Z'] / float( len(group['atoms'])) # # Now for the second residue # for residue2 in titgrps.keys(): for group2 in titgrps[residue2]: if not updater is None: updater('%d of %d (%4.1f%% completed)' % (count, ncalcs, float(count) / float(ncalcs) * 100.0)) count = count + 1 name2 = self.get_titgroup_name(residue2, group2) if self.matrix[name1].has_key(name2): continue # # Get center of atoms for this res # x2 = 0.0 y2 = 0.0 z2 = 0.0 for atom in group2['atoms']: x2 = x2 + self.atoms[residue2 + ':' + atom]['X'] / float( len(group2['atoms'])) y2 = y2 + self.atoms[residue2 + ':' + atom]['Y'] / float( len(group2['atoms'])) z2 = z2 + self.atoms[residue2 + ':' + atom]['Z'] / float( len(group2['atoms'])) # # Get the distance # v1 = numpy.array([x, y, z]) v2 = numpy.array([x2, y2, z2]) import geometry dist = geometry.length(v1 - v2) if dist != 0: crg1 = group['charge'] crg2 = group2['charge'] ene = factor * float(crg1 * crg2) / (math.pow( dist, 1.5)) # # Get the influence of the acc # acc_frac = math.sqrt(acc[name1] * acc[name2]) acc_frac = math.pow(acc_frac, 2.0) ene = ene * 1.99 * acc_frac + ( 1.0 - acc_frac) * float(eps) / float(exdi) * ene else: ene = 0.0 #if ene: # print '%20s - %20s: %7.3f' %(name1,name2,ene) self.matrix[name1][name2] = [ene, 0.0, 0.0, 0.0] self.distmatrix[name1][name2] = dist if not self.matrix.has_key(name2): self.matrix[name2] = {} self.matrix[name2] = {} self.matrix[name2][name1] = [ene, 0.0, 0.0, 0.0] self.distmatrix[name2][name1] = dist # # Write the matrix file # if filename: import pKaIO X = pKaIO.pKaIO() X.matrix = self.matrix X.write_matrix(filename + '.MATRIX.DAT') return self.matrix