def dictCheck(dictionary, value, subvalue, configName): map = LinkedHashMap() if type(dictionary) == dict: for k in dictionary.keys(): if type(k) != str: raise TypeError, configName + " key [" + ` k ` + "] not a str" l = dictionary[k] if type(l) != value: raise TypeError, configName + " value [" + `l` + "] not a " \ + `value` if value == list or value == tuple: n = ArrayList() for m in l: if type(m) != subvalue: raise TypeError, configName + " value [" + `l` \ + "] isn't a " + `subvalue` + ": " + `m` elif subvalue == int: n.add(Integer(m)) elif subvalue == float: n.add(Float(m)) else: n.add(m) map.put(k, n) else: if value == int: map.put(k, Integer(l)) elif value == float: map.put(k, Float(l)) else: map.put(k, l) else: raise TypeError, configName + " not a dict:" + ` dictionary ` return map
def addgroupattr(self, attrname, attrvalue, group=None, float=False): if float: if isinstance(attrvalue, (list, tuple)): for i in range(len(attrvalue)): attrvalue[i] = Float(attrvalue[i]) else: attrvalue = Float(attrvalue) return self.ncfile.addGroupAttribute(group, Attribute(attrname, attrvalue))
def interval(self, key, start, end): if isinstance(start, float): start_value = Float(start) else: start_value = start if isinstance(end, float): end_value = Float(end) else: end_value = end return self.__class__(self.pipeline.interval(key, start_value, end_value))
def getGlobals(mod): mp = HashMap() for attrName in mod.__dict__: if not attrName.startswith('__'): attr = mod.__getattribute__(attrName) t = type(attr) if t is not list: if t is str: mp.put(attrName, attr) elif t is int: mp.put(attrName, Integer(attr)) elif t is float: mp.put(attrName, Float(attr)) elif t is bool: mp.put(attrName, Boolean(attr)) else: arr = None if len(attr) > 0: t = type(attr[0]) if t is int: arr = __fillArray(attr, Integer) elif t is float: arr = __fillArray(attr, Float) elif t is str: arr = __fillArray(attr, String) mp.put(attrName, arr) return mp
def parse(self, query, field='', op='', parser=None, **attrs): """Return parsed lucene Query. :param query: query string :param field: default query field name, sequence of names, or boost mapping :param op: default query operator ('or', 'and') :param parser: custom PythonQueryParser class :param attrs: additional attributes to set on the parser """ # parsers aren't thread-safe (nor slow), so create one each time cls = queryparser.classic.QueryParser if isinstance(field, string_types) else queryparser.classic.MultiFieldQueryParser args = field, self if isinstance(field, collections.Mapping): boosts = HashMap() for key in field: boosts.put(key, Float(field[key])) args = list(field), self, boosts parser = (parser or cls)(*args) if op: parser.defaultOperator = getattr(queryparser.classic.QueryParser.Operator, op.upper()) for name, value in attrs.items(): setattr(parser, name, value) if isinstance(parser, queryparser.classic.MultiFieldQueryParser): return parser.parse(parser, query) try: return parser.parse(query) finally: if isinstance(parser, PythonQueryParser): parser.finalize()
def setup(core, actor, buff): #powerup = actor.getUseTarget() powerupID = actor.getAttachment('LastUsedPUP') powerup = core.objectService.getObject(long(powerupID)) effectName = powerup.getAttachment("effectName") powerValue = powerup.getAttachment("powerValue") effectName = effectName.replace('@stat_n:', '') actor.sendSystemMessage('en %s' % effectName, 0) actor.sendSystemMessage('pv %s' % powerValue, 0) buff.setDuration(Float(1800.0)) if effectName: buff.setEffect1Name(effectName) if powerValue: buff.setEffect1Value(Float(powerValue)) return
def putMaxRecommDose(guidelineDrug): doseLevelRanges = guidelineDrug.getOwnSlotValues( kb.getSlot("dose_level_ranges")) drugLabel = guidelineDrug.getOwnSlotValue(kb.getSlot("label")) maxRecommendedDoseLevel = guidelineDrug.getOwnSlotValue( kb.getSlot("max_recommended_dose_level")) if (maxRecommendedDoseLevel and maxRecommendedDoseLevel.getName() == "Medium_Dose"): print drugLabel + " has medium dose as the maximum recommended dose level" else: for dlr in doseLevelRanges: doseLevel = dlr.getOwnSlotValue(kb.getSlot("abstract_value")) if (doseLevel): if ((doseLevel.getName() == "High_Dose") or (doseLevel.getName() == "High_Dose(high/low)")): maxValue = dlr.getOwnSlotValue(kb.getSlot("upper_limit")) if (maxValue): guidelineDrug.setOwnSlotValue( kb.getSlot("max_recommended_dose"), Float(maxValue)) else: print "No max value for the high dose range of " + drugLabel else: print "No high dose level for " + drugLabel else: print "No nominal (abstract) dose level for a dose level range of " + drugLabel
def addgroupattr(self, attrname, attrvalue, group=None, float=False): ''' Add a global attribute. :param attrname: (*string*) Attribute name. :param attrvalue: (*object*) Attribute value. :param group: None means global attribute. :param float: (*boolean*) Transfer data as float or not. ''' if float: if isinstance(attrvalue, (list, tuple)): for i in range(len(attrvalue)): attrvalue[i] = Float(attrvalue[i]) else: attrvalue = Float(attrvalue) return self.ncfile.addGroupAttribute(group, Attribute(attrname, attrvalue))
def setIncreaseDoseCeiling(): for gd in kb.getCls("Guideline_Drug").getInstances(): LBofHighestLevel = getLBofHighestLevel( collection2List( gd.getOwnSlotValues(kb.getSlot("dose_level_ranges")))) if (LBofHighestLevel): gd.setOwnSlotValue(kb.getSlot("increase_dose_ceiling"), Float(LBofHighestLevel))
def __init__(self): head = 'Byte,Double,Float,Integer,Long,Short'.split(',') self.data = [[ Byte(Byte.MIN_VALUE), Double(Double.MIN_VALUE), Float(Float.MIN_VALUE), Integer(Integer.MIN_VALUE), Long(Long.MIN_VALUE), Short(Short.MIN_VALUE) ], [ Byte(Byte.MAX_VALUE), Double(Double.MAX_VALUE), Float(Float.MAX_VALUE), Integer(Integer.MAX_VALUE), Long(Long.MAX_VALUE), Short(Short.MAX_VALUE) ]] DefaultTableModel.__init__(self, self.data, head)
def __init__(self, data, headings): info = [] df = DateFormat.getDateInstance(DateFormat.SHORT) for tf, date, size, f, d in data: info.append([ Boolean(tf == '1'), df.parse(date), Integer(size.strip().replace(',', '')), Float(f), Double(d) ]) DefaultTableModel.__init__(self, info, headings)
def putDoseCeilings(guidelineDrug): doseLevelRanges = guidelineDrug.getOwnSlotValues( kb.getSlot("dose_level_ranges")) drugLabel = guidelineDrug.getOwnSlotValue(kb.getSlot("label")) maxRecommendedDoseLevel = guidelineDrug.getOwnSlotValue( kb.getSlot("max_recommended_dose_level")) if (maxRecommendedDoseLevel): for dlr in doseLevelRanges: doseLevel = dlr.getOwnSlotValue(kb.getSlot("abstract_value")) if (doseLevel): if (doseLevel == maxRecommendedDoseLevel): maxIncreaseDose = dlr.getOwnSlotValue( kb.getSlot("lower_limit")) if (maxIncreaseDose): guidelineDrug.setOwnSlotValue( kb.getSlot("increase_dose_ceiling"), Float(maxIncreaseDose)) else: print "No min dose for high dose level of " + drugLabel maxValue = dlr.getOwnSlotValue(kb.getSlot("upper_limit")) if (maxValue): guidelineDrug.setOwnSlotValue( kb.getSlot("max_recommended_dose"), Float(maxValue)) else: print "No max value for the high dose range of " + drugLabel else: print "No nominal (abstract) dose level for a dose level range of " + drugLabel else: print "No max_recommended_dose_level for " + drugLabel increaseDoseCeiling = guidelineDrug.getOwnSlotValue( kb.getSlot("increase_dose_ceiling")) maxDose = guidelineDrug.getOwnSlotValue(kb.getSlot("max_recommended_dose")) if (not (increaseDoseCeiling)): print "No increase dose ceiling for " + drugLabel if (not (maxDose)): print "No max dose for " + drugLabel
def saveBlock(featureName, block): if (featureName == None) or (len(block) == 0): return # Get the first (and only) plate of this model, or create one if it doesn't exist yet. plate = model.getPlate(0) if plate == None: plate = API.get("ModelUtils").createPlate(model, len(block), len(block[0])) for r in range(plate.getRows()): for c in range(plate.getColumns()): well = plate.getWell(r + 1, c + 1) featureValue = API.get("ModelUtils").newFeature(featureName, well) featureValue.setNumericValue(Float(float(block[r][c])))
def getResult(self): Dimension = self.getParameter(0).getStringValue() useDefaults = self.getParameter(1).value if Dimension == "1D": self.getParameter(7).setValue(Integer(-200)) self.getParameter(8).setValue(Integer(-200)) if useDefaults: Q = Vector() Q.addElement(Float(.0035)) X = .0035 for i in range(1, 117, 1): X = X * 1.05 Y = Float(X) Q.addElement(Float(X)) return Q else: return self.getParameter(2).getValue() else: Q = Vector() Q.addElement(self.getParameter(3).getValue()) Q.addElement(self.getParameter(4).getValue()) Q.addElement(self.getParameter(5).getValue()) Q.addElement(self.getParameter(6).getValue()) return Q
def sendMessage(self, oscAddress, *args): """ Sends an OSC message consisting of the 'oscAddress' and corresponding 'args' to the OSC output device. """ # HACK: For some reason, float OSC arguments do not work, unless they are explictly converted to Java Floats. # The following list comprehension does the trick. from java.lang import Float # for every argument, if it is a float cast it to a Java Float, otherwise leave unchanged args = [Float(x) if isinstance(x, float) else x for x in args] #print "sendMessage args = ", args oscMessage = OSCMessage( oscAddress, args ) # create OSC message from this OSC address and arguments self.portOut.send(oscMessage) # and send it to the OSC device that's listening to us # remember that this OscIn has been created and is active (so that it can be stopped/terminated by JEM, if desired) _ActiveOscOutObjects_.append(self)
def getProtonsCharge( instr, runnum): import os (nxs, prenxs) = getRunDir(instr, runnum) node = NexNode( nxs) for i in range(0,node.getNChildNodes()): n = node.getChildNode( i) if n.getNodeClass()=="NXentry": try: V = n.getChildNode("proton_charge").getNodeValue() F = ConvertDataTypes.floatValue(V) return Float(F).doubleValue() except: pass return Double.NaN
def __init__(self, index_dir, search_fields=['canonical_url', 'title', 'meta', 'content'], unique_field='uq_id_str', boost=dict(canonical_url=4.0, title=8.0, meta=2.0, content=1.0), date_format='%Y-%m-%dT%H:%M:%S'): """Constructor of Searcher. Parameters ---------- index_dir : string The location of lucene index. search_fields : list A list of field names indicating fields to search on. unique_field : string The field name, on which the duplication should avoid. boost : dict This dict control the weight when computing score. date_format : string Convert the string into datetime. Should consistent with the index part. """ self.index_dir = index_dir self.search_fields = search_fields self.sort_by_recent = Sort( SortField('date_published', SortField.Type.STRING, True)) self.store = FSDirectory.open(File(index_dir)) self.reader = DirectoryReader.open(self.store) self.isearcher = IndexSearcher(self.reader) self.analyzer = StandardAnalyzer() self.dup_filter = DuplicateFilter(unique_field) self.boost_map = HashMap() for k, v in boost.iteritems(): self.boost_map.put(k, Float(v)) self.mul_parser = MultiFieldQueryParser(search_fields, self.analyzer, self.boost_map) self.date_format = date_format
def getJavaValue(self, value, type): try: if type == AppilogTypes.LONG_DEF: return Long(value) if type == AppilogTypes.INTEGER_DEF: return Integer(value) if type == AppilogTypes.FLOAT_DEF: return Float(value) if type == AppilogTypes.DOUBLE_DEF: return Double(value) if type == AppilogTypes.BOOLEAN_DEF: return Boolean(value) return value except JavaException, ex: msg = ex.getMessage() info = logger.prepareJavaStackTrace() logger.debug(info) raise CiImportException, self.makeConversionMessage( 'Error while converting to type %s ' % type, msg)
import sys if sys.platform.startswith('java'): from java.lang import String, Integer, Long, Float, Short, Double varz = { 'java_string_int': String('1'), 'java_string_float': String('1.1'), 'java_string_hex': String('F00'), 'java_string_embedded_base': String('0xf00'), 'java_string_invalid': String('foobar'), 'java_integer': Integer(1), 'java_long': Long(1), 'java_short': Short(1), 'java_float': Float(1.1), 'java_double': Double(1.1) } else: varz = {} class MyObject: def __init__(self, value): self.value = value def __int__(self): return 42 / self.value def __str__(self): return 'MyObject'
imp = IJ.openImage("http://wsr.imagej.net/images/blobs.gif"); # IJ.openImage("C:/structure/data/blobs.gif"); # Init GPU from net.haesleinhuepf.clijx import CLIJx; clijx = CLIJx.getInstance(); # push data to GPU inputImage = clijx.push(imp); # blur a bit and detect maxima from java.lang import Float; blurred = clijx.create(inputImage); detected_spots = clijx.create(inputImage); clijx.op().blur(inputImage, blurred, Float(15), Float(15), Float(0)); print(str(blurred)); from java.lang import Integer; clijx.op().detectMaximaBox(blurred, detected_spots, Integer(10)); clijx.show(detected_spots, "spots"); # convert spots image to spot list number_of_spots = clijx.op().sumPixels(detected_spots); pointlist = clijx.create([number_of_spots, 2]); clijx.op().spotsToPointList(detected_spots, pointlist); distance_matrix = clijx.create([number_of_spots, number_of_spots]); clijx.op().generateDistanceMatrix(pointlist, pointlist, distance_matrix);
def test_remove(): assert set( g.E.weight) == {0.4000000059604645, 0.5, 1.0, 0.20000000298023224} g.E.has("weight", Float(0.5), 'lt').remove() assert set(g.E.weight) == {0.5, 1.0} assert len(g.E.weight) == 3
tempCLImage = clij.create([inputCLImage.getWidth(), inputCLImage.getHeight()], inputCLImage.getNativeType()) outputCLImage = clij.create( [inputCLImage.getWidth(), inputCLImage.getHeight()], inputCLImage.getNativeType()) # crop out a center plane of the 3D data set clij.op().copySlice(inputCLImage, tempCLImage, 64) # apply a filter to the image using ClearCL / OpenCL clij.execute( filesPath + "differenceOfGaussian.cl", "subtract_convolved_images_2d_fast", { "src": tempCLImage, "dst": outputCLImage, "radius": 6, "sigma_minuend": Float(1.5), "sigma_subtrahend": Float(3) }) # convert the result back to imglib2 and show it result = clij.pull(outputCLImage) result.show() IJ.run("Enhance Contrast", "saturated=0.35") # clean up inputCLImage.close() tempCLImage.close() outputCLImage.close()
def getFloatPosition(self, d): return Float(self.pos[d])
d[_v] = _id from java.lang import Long, Integer, Short, Character, Byte, Boolean, Double, Float, String from java.math import BigInteger values = [ 0, 0L, 0.0, 'c', "string", (), o, c, foo, subfoo, subfoo2, n, Object, Class, Foo, SubFoo, C, SubFoo2, N, Integer, Long(0), Integer(0), Short(0), Character('c'), Byte(0), Boolean(0), Double(0), Float(0), String("js"), BigInteger("0") ] def pp(v): inst = d.get(v, None) if inst is not None: return inst if hasattr(v, '__name__'): return v.__name__ if isinstance(v, (String, Number, Character, Boolean)): n = v.__class__.__name__ return "%s[%s]" % (n[n.rfind('.') + 1:], v) return repr(v)