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)
