DecodeThread(
CaptureActivity activity,
Vector<BarcodeFormat> decodeFormats,
String characterSet,
ResultPointCallback resultPointCallback) {
this.activity = activity;
handlerInitLatch = new CountDownLatch(1);
hints = new Hashtable<DecodeHintType, Object>(3);
if (decodeFormats == null || decodeFormats.isEmpty()) {
decodeFormats = new Vector<BarcodeFormat>();
decodeFormats.addAll(DecodeFormatManager.ONE_D_FORMATS);
decodeFormats.addAll(DecodeFormatManager.QR_CODE_FORMATS);
decodeFormats.addAll(DecodeFormatManager.DATA_MATRIX_FORMATS);
}
hints.put(DecodeHintType.POSSIBLE_FORMATS, decodeFormats);
if (characterSet != null) {
hints.put(DecodeHintType.CHARACTER_SET, characterSet);
}
hints.put(DecodeHintType.NEED_RESULT_POINT_CALLBACK, resultPointCallback);
}
public void setModel(Vector columnas, Vector vector) {
rows.removeAllElements();
rows.addAll(vector);
columnNames.removeAllElements();
columnNames.addAll(columnas);
fireTableStructureChanged(); // Actualiza La Tabla
}
public void addHijos(DefaultMutableTreeNode nodo) {
if (nodo.getChildCount() != 0) {
nodo.removeAllChildren();
}
Vector<String> ListaDir = new Vector<String>();
Vector<String> ListaArch = new Vector<String>();
DefaultMutableTreeNode upNode =
(nodo.isRoot()) ? nodo : (DefaultMutableTreeNode) nodo.getParent();
String Ruta = nodo.getUserObject().toString();
while (!upNode.isRoot()) {
Ruta = upNode.getUserObject().toString() + "\\" + Ruta;
upNode = (DefaultMutableTreeNode) upNode.getParent();
}
try {
Process sysCall;
BufferedReader br;
String s = "";
String strCmd = "cmd /c cd " + localDir + "\\" + Ruta + " & dir";
System.out.println(strCmd);
sysCall = Runtime.getRuntime().exec(strCmd);
br = new BufferedReader(new InputStreamReader(sysCall.getInputStream()));
while ((s = br.readLine()) != null) {
System.out.println(s);
int indexArch = " ".length();
if (s.contains("<DIR>")) {
int indexDir = s.indexOf("<DIR>") + "<DIR>".length() + 1;
String nomDir = s.substring(indexDir);
ListaDir.add(nomDir.trim());
} else {
String nomArch = (s.length() > indexArch) ? s.substring(indexArch) : s;
ListaArch.add(nomArch);
}
}
ListaDir = new Vector<String>(ListaDir.subList(2, ListaDir.size()));
ListaArch = new Vector<String>(ListaArch.subList(5, ListaArch.size() - 2));
int i;
for (i = 0; i < ListaDir.size(); i++) {
DefaultMutableTreeNode hijo = new DefaultMutableTreeNode(ListaDir.get(i).toString());
nodo.add(hijo);
}
for (i = 0; i < ListaArch.size(); i++) {
DefaultMutableTreeNode hijo = new DefaultMutableTreeNode(ListaArch.get(i).toString());
nodo.add(hijo);
}
ListaArchSup.addAll(ListaArch);
ListaDirSup.addAll(ListaDir);
} catch (Exception e) {
}
}
/** Sort all the painters (according to priority and name) */
protected void sortThem() {
sortByPriority.clear();
sortByName.clear();
sortByName.addAll(paintersByName.keySet());
Collections.sort(sortByName);
Vector<String> painterNames = new Vector<String>();
Vector<Integer> priorities = new Vector<Integer>();
painterNames.addAll(sortByName);
priorities.addAll(painterPriorities.values());
Collections.sort(priorities);
while (!priorities.isEmpty()) {
int prio = priorities.get(0);
priorities.remove(0);
for (int i = 0; i < painterNames.size(); i++) {
if (painterPriorities.get(painterNames.get(i)) == prio) {
sortByPriority.add(painterNames.get(i));
painterNames.remove(i);
break;
}
}
}
}
/**
* Returns a Collection of all flags supported by any of the regular-expression Compilers used by
* the plug-in.
*
* @return a Collection of all flags supported by any of the regular-expression Compilers used by
* the plug-in
*/
public static Collection getAllSupportedFlags() {
Vector allFlags = new Vector();
allFlags.addAll(MatchSetFactory.getAllFlags(JAVA_FLAVOUR));
allFlags.addAll(MatchSetFactory.getAllFlags(ORO_PERL_FLAVOUR));
allFlags.addAll(MatchSetFactory.getAllFlags(ORO_AWK_FLAVOUR));
return allFlags;
}
public Vector getAllValidTemplates() {
// Return templates if no imported/included stylesheets
if (_includedStylesheets == null) {
return _templates;
}
// Is returned value cached?
if (_allValidTemplates == null) {
Vector templates = new Vector();
templates.addAll(_templates);
int size = _includedStylesheets.size();
for (int i = 0; i < size; i++) {
Stylesheet included = (Stylesheet) _includedStylesheets.elementAt(i);
templates.addAll(included.getAllValidTemplates());
}
// templates.addAll(_templates);
// Cache results in top-level stylesheet only
if (_parentStylesheet != null) {
return templates;
}
_allValidTemplates = templates;
}
return _allValidTemplates;
}
private static void recurseDirectory(File directory, Vector<String> catTree) {
String[] contents = directory.list();
for (int i = 0; i < contents.length; i++) {
File innerFile = new File(directory, contents[i]);
if (innerFile.isFile()) {
if ("domains".equals(contents[i])) {
try {
BufferedReader reader = new BufferedReader(new FileReader(innerFile));
while (true) {
String line = reader.readLine();
if (line == null) break;
Vector<String> vals = domains.get(line);
if (vals == null) {
Vector<String> newVals = new Vector<String>();
newVals.addAll(catTree);
domains.put(line, newVals);
} else {
vals.addAll(catTree);
domains.put(line, vals);
}
}
reader.close();
} catch (Throwable t) {
t.printStackTrace();
}
catTree.remove(catTree.size() - 1);
}
} else {
System.out.println("> " + contents[i]);
catTree.add(contents[i]);
recurseDirectory(innerFile, catTree);
}
}
}
public List getSupportedOptions() {
Vector ret = new Vector();
ret.addAll(options);
for (int i = 0; i < elements.length; i++) {
ret.addAll(elements[i].getSupportedOptions());
}
return ret;
}
public Vector<Byte> makeByteArray() {
Vector<Byte> b = new Vector<Byte>();
b.addAll(convertToByte(coffCabStart, 4));
b.addAll(convertToByte(cCFData, 2));
b.addAll(convertToByte(typeCompress, 2));
return b;
}
/** Speichert die Standardkonfigurationsdatei. */
private void saveCompleteConfig() {
Vector<MulticastData> v = new Vector<MulticastData>();
v.addAll(mc_sender_v4);
v.addAll(mc_sender_v6);
v.addAll(mc_receiver_v4);
v.addAll(mc_receiver_v6);
saveConfig("", true, v);
}
/**
* Returns an enumeration describing the available options.
*
* @return an enumeration of all the available options.
*/
public Enumeration<Option> listOptions() {
Vector<Option> result = new Vector<Option>();
result.addElement(
new Option("\tThe complexity constant C.\n" + "\t(default 1)", "C", 1, "-C <double>"));
result.addElement(
new Option(
"\tWhether to 0=normalize/1=standardize/2=neither.\n" + "\t(default 0=normalize)",
"N",
1,
"-N"));
result.addElement(
new Option(
"\tOptimizer class used for solving quadratic optimization problem\n"
+ "\t(default "
+ RegSMOImproved.class.getName()
+ ")",
"I",
1,
"-I <classname and parameters>"));
result.addElement(
new Option(
"\tThe Kernel to use.\n"
+ "\t(default: weka.classifiers.functions.supportVector.PolyKernel)",
"K",
1,
"-K <classname and parameters>"));
result.addAll(Collections.list(super.listOptions()));
result.addElement(
new Option(
"",
"",
0,
"\nOptions specific to optimizer ('-I') "
+ getRegOptimizer().getClass().getName()
+ ":"));
result.addAll(Collections.list(((OptionHandler) getRegOptimizer()).listOptions()));
result.addElement(
new Option(
"",
"",
0,
"\nOptions specific to kernel ('-K') " + getKernel().getClass().getName() + ":"));
result.addAll(Collections.list(((OptionHandler) getKernel()).listOptions()));
return result.elements();
}
public Vector<SSObject> getAllInactiveParticipants() {
Vector<SSObject> all = new Vector<SSObject>();
all.addAll(getAllInactiveTimothys());
all.addAll(getAllInactiveRedas());
all.addAll(getAllInactiveCodes());
all.addAll(getAllInactiveProjs());
all.addAll(getAllInactiveAssociatedUserStoriess());
all.addAll(getAllInactiveReleasePlans());
return all;
}
/** Load all available data from the master into the list */
private void fillList() {
MeasurementHistoryController hist = master.getHistoryController();
this.dataList.removeAll();
Vector<String> tmp = new Vector<String>();
tmp.addAll(hist.getDataHours().keySet());
this.addKeys(tmp, "hours");
tmp.removeAllElements();
tmp.addAll(hist.getDataDays().keySet());
this.addKeys(tmp, "days");
}
/**
* add the ver id from the vToRemove to this vertex previous ids
*
* @param vToKeep
* @param vToRemove
*/
public void addToPrevIDs(SeqVertex vToKeep, SeqVertex vToRemove, int lastRealID) {
if (_prevVerticesID.isEmpty()) {
Vector<Integer> thisV = new Vector<Integer>();
if (vToKeep.getID() >= lastRealID) thisV.add(vToKeep.getID());
if (vToRemove.getID() >= lastRealID) thisV.add(vToRemove.getID());
if (!vToKeep.getPrevVerIDs().isEmpty()) thisV.addAll(vToKeep.getPrevVerIDs().firstElement());
if (!vToRemove.getPrevVerIDs().isEmpty())
thisV.addAll(vToRemove.getPrevVerIDs().firstElement());
_prevVerticesID.add(thisV);
} else {
assert (true);
}
}
public DecoderBitmap(Context context) {
multiFormatReader = new MultiFormatReader();
Hashtable<DecodeHintType, Object> hints = new Hashtable<DecodeHintType, Object>(2);
Vector<BarcodeFormat> decodeFormats = new Vector<BarcodeFormat>();
if (decodeFormats == null || decodeFormats.isEmpty()) {
decodeFormats = new Vector<BarcodeFormat>();
decodeFormats.addAll(DecodeFormatManager.getBarCodeFormats());
decodeFormats.addAll(DecodeFormatManager.getQrCodeFormats());
decodeFormats.addAll(EnumSet.of(BarcodeFormat.AZTEC));
decodeFormats.addAll(EnumSet.of(BarcodeFormat.PDF_417));
}
hints.put(DecodeHintType.POSSIBLE_FORMATS, decodeFormats);
hints.put(DecodeHintType.CHARACTER_SET, "UTF8");
multiFormatReader.setHints(hints);
}
public AColumnDisplayerModel(ObjectAdapter theAdapter) {
adapter = theAdapter;
parentClass = adapter.getParentAdapter().getPropertyClass();
CompositeAdapter parentAdapter = adapter.getParentAdapter();
BeanToRecord recordStructure = (BeanToRecord) parentAdapter.getConcreteObject();
componentNames = recordStructure.componentNames();
projectionGroups = adapter.getParentAdapter().getUnParsedProjectionGroups();
processProjectionGroups();
processComponentNames();
dynamicCommandsVector.addAll(projectionGroupCommands);
dynamicCommandsVector.addAll(allSiblingCommands);
dynamicCommands = new String[0];
dynamicCommands = dynamicCommandsVector.toArray(dynamicCommands);
}
@Override
public IplImage process(IplImage img) {
/*
if(convertFromColor) {
imageConversion.convertFromRGB(img, grayImage);
} else {
imageConversion.convertFromGray(img, grayImage);
}
*/
blur.apply(grayImage, blurImage);
IplImage bkImage = background.update(blurImage);
if (bkImage == null) return null;
ImageDifference.apply(bkImage, blurImage, diffImage);
thresh.apply(diffImage, threshImage);
synchronized (blobs) {
Vector<Blob> allBlobs = new Vector<Blob>(newFrameBlobs.size());
// probably should come up with some kind of double (or triple buffer) for this rather than
// re-allocating vectors every frame
blobs.detectBlobs(threshImage2.getData());
for (int i = 0; i < regionMap.size(); i++) {
Vector<Blob> detected = blobs.getDetectedBlobs(i);
Vector<Blob> newBlobs = new Vector<Blob>(detected.size());
newBlobs.addAll(detected);
allBlobs.addAll(detected);
tracker[i].queueBlobs(newBlobs);
}
newFrameBlobs = allBlobs;
}
switch (mode) {
case raw:
return img;
case background:
return bkImage;
case diff:
return diffImage;
case thresh:
case running:
return threshImage2;
default:
return img;
}
}
protected void updateTransientActions() {
Vector<Action> ta = new Vector<Action>();
for (LabelAtomProperty p : properties) ta.addAll(p.getActions(this));
transientActions = ta;
}
/**
* Builds a {@link java.util.Vector} containing Strings which each name a file who's name matches
* the pattern set by setPattern(String). The classpath is searched recursively, so use with
* caution.
*
* @return Vector<String> containing matching filenames
*/
public Vector<String> findMatches() {
Vector<String> matches = new Vector<String>();
URLClassLoader cl = getURLClassLoader();
if (cl == null) {
throw new XWorkException("unable to attain an URLClassLoader");
}
URL[] parentUrls = cl.getURLs();
compiledPattern = (int[]) patternMatcher.compilePattern(pattern);
for (URL url : parentUrls) {
if (!"file".equals(url.getProtocol())) {
continue;
}
URI entryURI;
try {
entryURI = url.toURI();
} catch (URISyntaxException e) {
continue;
}
File entry = new File(entryURI);
Vector<String> results = checkEntries(entry.list(), entry, "");
if (results != null) {
matches.addAll(results);
}
}
return matches;
}
/**
* Helper method to generate the signatures for binding the factory. Must account for the
* inheritance relationships for any arguments that are classes. Ths, each argument can
* potentially result in a range of values for type, and we have to handle the cross product of
* all of these.
*/
private static Vector makeFactoryNames(IXMLElement constructor) {
String factoryName = XMLUtil.nameOf(constructor.getParent());
Vector allPermutations = new Vector();
for (Enumeration e = constructor.enumerateChildren(); e.hasMoreElements(); ) {
IXMLElement element = (IXMLElement) e.nextElement();
if (!element.getName().equals("arg")) {
break;
}
String argType = XMLUtil.typeOf(element);
Vector argTypeAlternates = new Vector();
argTypeAlternates.add(argType);
if (ModelAccessor.isClass(argType)) {
List ancestors = ModelAccessor.getAncestors(argType);
if (ancestors != null) argTypeAlternates.addAll(ancestors);
}
allPermutations.add(argTypeAlternates);
}
// Generate all the signatures
Vector factoryNames = new Vector();
makeFactoryNames(factoryName, allPermutations, 0, factoryNames);
return factoryNames;
}
private void deriveUprocVariables() throws Exception {
if (isTempUprocSet) {
Vector<Variable> varia = new Vector<Variable>();
varia.addAll(templateCabrinUproc.getVariables());
if (varia.size() == 3
&& varia.get(1).getName().equals("COMMAND_PART2")
&& varia.get(2).getName().equals("MAIN_JOB_TRIGGER")) {
String command = varia.get(1).getValue();
command = command.replace("-S00", "-S" + googleNumber);
command = command.replace("<FILE>", fileName);
varia.get(1).setValue(command);
String main_job_trigger = varia.get(2).getValue();
main_job_trigger = main_job_trigger.replace("<JOB>", relatedMainUproc);
varia.get(2).setValue(main_job_trigger);
}
variables = varia;
if (!duapi.doesUprocExist(relatedCabrinUproc)) {
UprocId newDuplicatedUprocId = new UprocId(relatedCabrinUproc, "000");
newDuplicatedUprocId.setId(relatedCabrinUproc);
templateCabrinUproc.duplicate(newDuplicatedUprocId, "CABRIN");
// duapi.duplicateUproc(templateCabrinUproc.getName(), relatedCabrinUproc,"CABRIN");
System.out.println("Created uproc <" + relatedCabrinUproc + ">");
}
}
}
void m() {
Vector<String> vector = new Vector<String>();
vector.add("Hello");
Vector<CharSequence> v2 = new Vector<CharSequence>();
v2.add((CharSequence) null);
v2.addAll(vector);
}
private void visit(Set<Edge> visited) {
boolean fixpoint = false;
while (!fixpoint) {
fixpoint = true;
Vector<Vector<Edge>> newPaths = new Vector<Vector<Edge>>();
Vector<Vector<Edge>> delPaths = new Vector<Vector<Edge>>();
for (Vector<Edge> path : paths) {
Edge e = path.lastElement();
boolean pathExtended = false;
for (Edge succ : e.getTarget().getSucc()) {
if (!visited.contains(succ)) {
Vector<Edge> newPath = new Vector<Edge>();
newPath.addAll(path);
newPath.add(succ);
newPaths.add(newPath);
visited.add(succ);
pathExtended = true;
fixpoint = false;
}
}
if (pathExtended) delPaths.add(path);
}
for (Vector<Edge> path : delPaths) paths.remove(path);
paths.addAll(newPaths);
}
}
/**
* Gets the current settings of the Classifier.
*
* @return an array of strings suitable for passing to setOptions
*/
@Override
public String[] getOptions() {
Vector<String> result;
String[] clustererOptions;
result = new Vector<String>();
clustererOptions = new String[0];
if ((m_clusterer != null) && (m_clusterer instanceof OptionHandler)) {
clustererOptions = ((OptionHandler) m_clusterer).getOptions();
}
if (getClusterer() != null) {
result.add("-W");
result.add(getClusterer().getClass().getName());
}
if (getNoSizeDetermination()) {
result.add("-no-size");
}
result.add("--");
result.addAll(Arrays.asList(clustererOptions));
return result.toArray(new String[result.size()]);
}
/*
* add the given vertex info into this vertex
* combine name and weights
*/
public void concatVertex(SeqVertex vertex, Double w, int lastRealID) {
int prevLen = getName().length();
setName(getName() + vertex.getName());
_weights.add(w);
_weights.addAll(vertex.getWeights());
// System.out.println(toStringWeights());
Vector<Integer> newV = new Vector<Integer>();
if (vertex.getID() <= lastRealID) {
newV.add(vertex.getID());
_prevVerticesID.add(newV);
}
_prevVerticesID.addAll(vertex.getPrevVerIDs());
if (vertex.getDegenerativeFreq().size() > 0) {
// System.err.println(vertex.getID()+":"+vertex.getDegenerativeFreq());
// System.err.println(vertex.getID()+":"+vertex.getDegenerativeLocations());
// System.err.println(vertex.getID()+":"+vertex.getDegenerativeLetters());
// System.err.println(getID()+":"+getName());
// System.err.println(prevLen);
_degenerativeLocations.add(prevLen + 1);
_degenerativeFreq.addAll(vertex.getDegenerativeFreq());
_degenerativeLetters.addAll(vertex.getDegenerativeLetters());
}
}
protected void addSample(Sample sample) {
boolean found = false;
for (int i = 0; i < sessions.size(); i++) {
if (notNewerThanThisSession(sample, sessions.get(i))) {
if (!sessions.get(i).isDuplicate(sample, duplicatesWindow)) {
int diffLost = sessions.get(i).numberOfLostSamples();
sessions.get(i).receivedSample(sample);
diffLost = sessions.get(i).numberOfLostSamples() - diffLost;
numberOfCollectedSamples++;
numberOfLostSamples += diffLost;
}
found = true;
break;
}
}
if (!found) {
sessionId++;
Session session = new Session(sessionId, sample);
session.receivedSample(sample);
sessions.add(session);
while (sessions.size() > NUM_MAX_RECORDED_SESSIONS) {
lostSamples.addAll(sessions.remove(0).getLostSamplesPeriods());
}
numberOfCollectedSamples++;
}
}
// //////////////////////////////////////////////////////
// Override
// //////////////////////////////////////////////////////
@SuppressWarnings({"rawtypes", "unchecked"})
public Vector getDispatcherDefinition() {
Vector vtReturn = new Vector();
vtReturn.addElement(ThreadUtil.createTextParameter("deliveryUser", 30, ""));
// vtReturn.addElement(ThreadUtil.createTextParameter("channel", 30, ""));
vtReturn.addElement(ThreadUtil.createComboParameter("channel", "SMS,web", ""));
vtReturn.addElement(ThreadUtil.createTextParameter("serviceAddress", 30, ""));
vtReturn.addElement(ThreadUtil.createTextParameter("isdn", 30, ""));
vtReturn.addElement(
ThreadUtil.createTextParameter(
"endIsdn",
30,
"If parameter is set, the simulator send order of subscribers range from isdn to endIsdn."));
vtReturn.addElement(ThreadUtil.createTextParameter("shipTo", 30, ""));
vtReturn.addElement(ThreadUtil.createTextParameter("keyword", 30, ""));
vtReturn.addElement(ThreadUtil.createTextParameter("batchSize", 30, ""));
vtReturn.addElement(ThreadUtil.createIntegerParameter("timeBetweenLoop", ""));
vtReturn.addElement(
ThreadUtil.createIntegerParameter("orderTimeout", "Time to live of order (s)."));
vtReturn.addAll(ThreadUtil.createQueueParameter(this));
return vtReturn;
}
public void substRef(Vector v, int pos, Vector entries) {
KlassenMerkmale k;
FlexMerkmal fm;
KategorieMerkmal km;
Enumeration e;
Vector kmv = new Vector(); // Vector mit KategorieMerkmal - Eintr�gen
// Hole Kategorie Merkmal
km = (KategorieMerkmal) v.get(pos);
// Verweis Kategorie Merkmale suchen:
e = entries.elements();
while (e.hasMoreElements()) {
k = (KlassenMerkmale) e.nextElement();
kmv.addAll(k.klassenVon(klasse));
}
// Flexionsinformationen ersetzen -- derzeit unvollst�ndig
// (sollte kmv tats�chlich mehrere Elemente enthalten
// m�sste km entsprechend oft geclont werden
// und dann wieder in v eingef�gt werden ...)
if (kmv.size() > 0) {
fm = ((KategorieMerkmal) kmv.get(0)).getFlexInfo();
if (fm != null) km.setFlexRef(fm);
}
}
/**
* Returns an enumeration describing the available options.
*
* @return an enumeration of all the available options.
*/
@Override
public Enumeration<Option> listOptions() {
Vector<Option> newVector = new Vector<Option>(2);
newVector.addElement(
new Option(
"\tSkips the determination of sizes (train/test/clusterer)\n"
+ "\t(default: sizes are determined)",
"no-size",
0,
"-no-size"));
newVector.addElement(
new Option(
"\tThe full class name of the density based clusterer.\n" + "\teg: weka.clusterers.EM",
"W",
1,
"-W <class name>"));
if ((m_clusterer != null) && (m_clusterer instanceof OptionHandler)) {
newVector.addElement(
new Option(
"",
"",
0,
"\nOptions specific to clusterer " + m_clusterer.getClass().getName() + ":"));
newVector.addAll(Collections.list(((OptionHandler) m_clusterer).listOptions()));
}
return newVector.elements();
}
private static Collection<PayloadFingerprint> parse(SetEntityParameters msg) {
Vector<PayloadFingerprint> pf = new Vector<>();
if (msg.getName().equals("Sidescan")) {
boolean active = false;
Vector<PayloadFingerprint> sidescanRanges = new Vector<>();
for (EntityParameter p : msg.getParams()) {
if (p.getName().equals("Range")
|| p.getName().equals("High-Frequency Range")
|| p.getName().equals("Low-Frequency Range")) {
sidescanRanges.add(new SidescanFingerprint(Double.parseDouble(p.getValue())));
} else if (p.getName().equals("Active")) {
active = p.getValue().equalsIgnoreCase("true");
}
}
if (active) pf.addAll(sidescanRanges);
} else if (msg.getName().equals("Multibeam")) {
double range = 0;
boolean active = false;
for (EntityParameter p : msg.getParams()) {
if (p.getName().equals("Active")) {
active = p.getValue().equalsIgnoreCase("true");
} else if (p.getName().equals("Range")) {
range = Double.parseDouble(p.getValue());
}
}
if (active) {
pf.add(new MultibeamFingerprint(range, Math.toRadians(60)));
}
}
return pf;
}
