/// <summary> Extracts selected fields from a message. /// /// </summary> /// <param name="theMessageText">an unparsed message from which to get fields /// </param> /// <param name="thePathSpecs">Terser-like paths to fields in the message. See documentation /// for Terser. These paths are identical except that they start with the segment /// name (search flags and group names are to be omitted as they are not relevant /// with unparsed ER7 messages). /// </param> /// <returns> field values corresponding to the given paths /// </returns> /// <throws> HL7Exception </throws> public static System.String[] getFields(System.String theMessageText, System.String[] thePathSpecs) { NuGenDatumPath[] paths = new NuGenDatumPath[thePathSpecs.Length]; for (int i = 0; i < thePathSpecs.Length; i++) { SupportClass.Tokenizer tok = new SupportClass.Tokenizer(thePathSpecs[i], "-", false); System.String segSpec = tok.NextToken(); tok = new SupportClass.Tokenizer(segSpec, "()", false); System.String segName = tok.NextToken(); if (segName.Length != 3) { throw new NuGenHL7Exception("In field path, " + segName + " is not a valid segment name"); } int segRep = 0; if (tok.HasMoreTokens()) { System.String rep = tok.NextToken(); try { segRep = System.Int32.Parse(rep); } catch (System.FormatException e) { throw new NuGenHL7Exception("In field path, segment rep" + rep + " is not valid", e); } } int[] indices = Terser.getIndices(thePathSpecs[i]); paths[i] = new NuGenDatumPath(); paths[i].add(segName).add(segRep); paths[i].add(indices[0]).add(indices[1]).add(indices[2]).add(indices[3]); } return getFields(theMessageText, paths); }
/// <summary> Reads given "property file" and sets system properties accordingly. In the property file, /// there should be one property per line. A line should consist of 1) the fully qualified property name, /// 2) one or more tabs, and 3) the value (everything after the first group of tabs and before any subsequent /// groups will be considered "the value"). /// Lines in the file are consdidered comments if they begin with "%". /// </summary> public static void loadProperties(System.String propertyFileName) { //open stream from given property file System.IO.StreamReader in_Renamed = null; in_Renamed = new System.IO.StreamReader(new System.IO.StreamReader(propertyFileName, System.Text.Encoding.Default).BaseStream, new System.IO.StreamReader(propertyFileName, System.Text.Encoding.Default).CurrentEncoding); System.String line, key, value_Renamed, delim = "\t"; SupportClass.Tokenizer tok; while ((line = in_Renamed.ReadLine()) != null) { //ignore comments if (!line.StartsWith("%")) { key = null; value_Renamed = null; //get property key and value tok = new SupportClass.Tokenizer(line, delim, false); if (tok.HasMoreTokens()) key = tok.NextToken(); if (tok.HasMoreTokens()) value_Renamed = tok.NextToken(); } } in_Renamed.Close(); }
} //end method /// <summary> Checks a code for an exact match, and using certain sequences where some /// characters are wildcards (e.g. HL7nnnn). If the pattern contains one of /// " or ", " OR ", or "," each operand is checked. /// </summary> private bool checkCode(System.String code, System.String pattern) { bool match = false; //mod by Neal acharya - Do full match on with the pattern. If code matches pattern then return true //else parse pattern to look for wildcard characters if (code.Equals(pattern)) { match = true; } //end if else { if (pattern.IndexOf(' ') >= 0 || pattern.IndexOf(',') >= 0) { SupportClass.Tokenizer tok = new SupportClass.Tokenizer(pattern, ", ", false); while (tok.HasMoreTokens() && !match) { System.String t = tok.NextToken(); if (!t.ToUpper().Equals("or".ToUpper())) match = checkCode(code, t); } //end while } //end if else { if (code.Equals(pattern)) { match = true; } } //end else } //end else return match; } //end method
/// <summary> <p>A convenience method for binding applications to an <code>ApplicationRouter</code> /// Information about bindings is read from a file at a specified URL. Each line in the /// file should have the following format (entries TAB delimited):</p> /// /// <p>message_type 	 trigger_event 	 processing_id 	 version_id 	 app_class</p> /// /// <p>Note that the first four fields can be the wildcard "*", which means any.</p> /// /// <p>For example, if you write an Application called org.yourorganiztion.ADTProcessor /// that processes several types of ADT messages, and another called /// org.yourorganization.ResultProcessor that processes result messages, you might have a /// file that looks like this: </p> /// /// <p>ADT 	 * 	 * 	 * 	 org.yourorganization.ADTProcessor<br> /// ORU 	 R01 	 * 	 * 	 org.yourorganization.ResultProcessor</p> /// /// <p>Each class listed in this file must implement either Genetibase.NuGenHL7.app.Application or /// Genetibase.NuGenHL7.protocol.ReceivingApplication, and must have a zero-argument constructor.</p> /// /// </summary> /// <param name="theRouter">the <code>ApplicationRouter</code> on which to make the binding /// </param> /// <param name="theSource">a URL pointing to the bindings file /// </param> public static void loadApplications(NuGenApplicationRouter theRouter, System.Uri theSource) { if (theSource == null) { throw new NuGenHL7Exception("Can't load application bindings: the given URL is null"); } System.IO.StreamReader in_Renamed = new System.IO.StreamReader(new System.IO.StreamReader(System.Net.WebRequest.Create(theSource).GetResponse().GetResponseStream(), System.Text.Encoding.Default).BaseStream, new System.IO.StreamReader(System.Net.WebRequest.Create(theSource).GetResponse().GetResponseStream(), System.Text.Encoding.Default).CurrentEncoding); System.String line = null; while ((line = in_Renamed.ReadLine()) != null) { //parse application registration information SupportClass.Tokenizer tok = new SupportClass.Tokenizer(line, "\t", false); System.String type = null, event_Renamed = null, procId = null, verId = null, className = null; if (tok.HasMoreTokens()) { //skip blank lines try { type = tok.NextToken(); event_Renamed = tok.NextToken(); procId = tok.NextToken(); verId = tok.NextToken(); className = tok.NextToken(); } catch (System.ArgumentOutOfRangeException) { throw new NuGenHL7Exception("Can't register applications from " + theSource.ToString() + ". The line '" + line + "' is not of the form: message_type [tab] trigger_event " + "[tab] processing ID [tab] version ID [tab] application_class. " + "*** NOTE TWO NEW FIELDS AS OF HAPI 0.5 ****. ", NuGenHL7Exception.APPLICATION_INTERNAL_ERROR); } System.Type appClass = System.Type.GetType(className); //may throw ClassNotFoundException System.Object appObject = System.Activator.CreateInstance(appClass); NuGenReceivingApplication app = null; if (appObject is NuGenReceivingApplication) { app = (NuGenReceivingApplication) appObject; } else if (appObject is Application) { app = new NuGenAppWrapper((Application) appObject); } else { throw new NuGenHL7Exception("The specified class, " + appClass.FullName + ", doesn't implement Application or ReceivingApplication.", NuGenHL7Exception.APPLICATION_INTERNAL_ERROR); } Genetibase.NuGenHL7.protocol.AppRoutingData rd = new NuGenAppRoutingDataImpl(type, event_Renamed, procId, verId); theRouter.bindApplication(rd, app); } } }
public FileExtFilter(System.String descroot, System.String suffixes) { //UPGRADE_ISSUE: The following fragment of code could not be parsed and was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1156'" exts = new List<String>(); SupportClass.Tokenizer tok = new SupportClass.Tokenizer(suffixes, ";"); while (tok.HasMoreTokens()) exts.Add(tok.NextToken()); descr = descroot + " ("; for (int n = 0; n < exts.Count; n++) descr = descr + (n > 0?" ":"") + "*" + exts[n]; descr = descr + ")"; }
/// <summary> /// Load a properties file from the templatePath defined in the /// generator. As the templatePath can contains multiple paths, /// it will cycle through them to find the file. The first file /// that can be successfully loaded is considered. (kind of /// like the java classpath), it is done to clone the Velocity /// process of loading templates. /// </summary> /// <param name="propertiesFile">the properties file to load. It must be /// a relative pathname. /// </param> /// <returns>a properties instance loaded with the properties from /// the file. If no file can be found it returns an empty instance. /// </returns> protected internal virtual ExtendedProperties loadFromTemplatePath(System.String propertiesFile) { ExtendedProperties properties = new ExtendedProperties(); System.String templatePath = Generator.Instance.TemplatePath; // We might have something like the following: // // #set ($dbprops = $properties.load("$generator.templatePath/path/props") // // as we have in Torque but we want people to start using // // #set ($dbprops = $properties.load("path/props") // // so that everything works from the filesystem or from // a JAR. So the actual Generator.getTemplatePath() // is not deprecated but it's use in templates // should be. SupportClass.Tokenizer st = new SupportClass.Tokenizer(templatePath, ","); while (st.HasMoreTokens()) { System.String templateDir = st.NextToken(); try { // If the properties file is being pulled from the // file system and someone is using the method whereby // the properties file is assumed to be in the template // path and they are simply using: // // #set ($dbprops = $properties.load("props") (1) // // than we have to tack on the templatePath in order // for the properties file to be found. We want (1) // to work whether the generation is being run from // the file system or from a JAR file. System.String fullPath = propertiesFile; // FIXME probably not that clever since there could be // a mix of file separators and the test will fail :-( if (!fullPath.StartsWith(templateDir)) { fullPath = templateDir + "\\" + propertiesFile; } properties.Load(new System.IO.FileStream(fullPath, System.IO.FileMode.Open, System.IO.FileAccess.Read)); // first pick wins, we don't need to go further since // we found a valid file. break; } catch (System.Exception) { // do nothing } } return properties; }
/// <param name="theScope">must be in the form type^event (ie message type and trigger event separated /// by a carat) /// </param> public override bool appliesToScope(System.String theScope) { if (!Regex.IsMatch(theScope, ".*\\^.*")) { throw new System.ArgumentException("arg theScope must be of the form type^event"); } SupportClass.Tokenizer tok = new SupportClass.Tokenizer(theScope, delim, false); System.String itemType = tok.NextToken(); System.String itemEvent = tok.NextToken(); throw new Exception("This method is invalid"); //return applies; }
/// <summary> Encodes the given message and compares it to the given string. Any differences /// are noted in the file [hapi.home]/parse_check.txt. Ignores extra field delimiters. /// </summary> public static void checkParse(System.String originalMessageText, Message parsedMessage, Parser parser) { System.String newMessageText = parser.encode(parsedMessage); if (!originalMessageText.Equals(newMessageText)) { //check each segment SupportClass.Tokenizer tok = new SupportClass.Tokenizer(originalMessageText, "\r"); System.Collections.ArrayList one = new System.Collections.ArrayList(); while (tok.HasMoreTokens()) { System.String seg = tok.NextToken(); if (seg.Length > 4) one.Add(seg); } tok = new SupportClass.Tokenizer(newMessageText, "\r"); System.Collections.ArrayList two = new System.Collections.ArrayList(); while (tok.HasMoreTokens()) { System.String seg = tok.NextToken(); if (seg.Length > 4) two.Add(stripExtraDelimiters(seg, seg[3])); } if (one.Count != two.Count) { } else { //check each segment for (int i = 0; i < one.Count; i++) { System.String origSeg = (System.String) one[i]; System.String newSeg = (System.String) two[i]; if (!origSeg.Equals(newSeg)) { } } } } else { } }
/// <summary> Splits the given composite string into an array of components using the given /// delimiter. /// </summary> public static String[] Split(String composite, String delim) { ArrayList components = new ArrayList(); //defend against evil nulls if (composite == null) { composite = ""; } if (delim == null) { delim = ""; } SupportClass.Tokenizer tok = new SupportClass.Tokenizer(composite, delim, true); bool previousTokenWasDelim = true; while (tok.HasMoreTokens()) { String thisTok = tok.NextToken(); if (thisTok.Equals(delim)) { if (previousTokenWasDelim) { components.Add(null); } previousTokenWasDelim = true; } else { components.Add(thisTok); previousTokenWasDelim = false; } } String[] ret = new String[components.Count]; for (int i = 0; i < components.Count; i++) { ret[i] = ((String)components[i]); } return(ret); }
private System.String[] getMSHFields(SupportClass.Tokenizer tok, char fieldSep) { System.String[] result = new System.String[21]; result[0] = System.Convert.ToString(fieldSep); System.String token = null; int field = 1; while (tok.HasMoreTokens() && (token = tok.NextToken())[0] != ourSegmentSeparator) { if (token[0] == fieldSep) { field++; } else { result[field] = token; } } return(result); }
/// <summary>Gets path information from a path spec. </summary> private PathSpec ParsePathSpec(string spec) { var ps = new PathSpec(this); if (spec.StartsWith(".")) { ps.Find = true; spec = spec.Substring(1); } else { ps.Find = false; } if (spec.Length == 0) { throw new HL7Exception("Invalid path (some path element is either empty or contains only a dot)"); } var tok = new SupportClass.Tokenizer(spec, "()", false); ps.Pattern = tok.NextToken(); if (tok.HasMoreTokens()) { var repString = tok.NextToken(); try { ps.Rep = int.Parse(repString); } catch (FormatException) { throw new HL7Exception(repString + " is not a valid rep #", ErrorCode.APPLICATION_INTERNAL_ERROR); } } else { ps.Rep = 0; } return(ps); }
/// <summary> Given a Terser path, returns an array containing field num, field rep, /// component, and subcomponent. /// </summary> public static int[] getIndices(String spec) { SupportClass.Tokenizer tok = new SupportClass.Tokenizer(spec, "-", false); tok.NextToken(); //skip over segment if (!tok.HasMoreTokens()) { throw new HL7Exception("Must specify field in spec " + spec, HL7Exception.APPLICATION_INTERNAL_ERROR); } int[] ret = null; try { SupportClass.Tokenizer fieldSpec = new SupportClass.Tokenizer(tok.NextToken(), "()", false); int fieldNum = Int32.Parse(fieldSpec.NextToken()); int fieldRep = 0; if (fieldSpec.HasMoreTokens()) { fieldRep = Int32.Parse(fieldSpec.NextToken()); } int component = 1; if (tok.HasMoreTokens()) { component = Int32.Parse(tok.NextToken()); } int subcomponent = 1; if (tok.HasMoreTokens()) { subcomponent = Int32.Parse(tok.NextToken()); } int[] result = new int[] { fieldNum, fieldRep, component, subcomponent }; ret = result; } catch (FormatException) { throw new HL7Exception("Invalid integer in spec " + spec, HL7Exception.APPLICATION_INTERNAL_ERROR); } return(ret); }
/// <seealso cref="Genetibase.NuGenHL7.parser.Parser.doParse(java.lang.String, java.lang.String)"> /// </seealso> protected internal override Message doParse(System.String message, System.String version) { Message result = null; char fieldSep = message[3]; NuGenEncodingCharacters ec = new NuGenEncodingCharacters(fieldSep, message.Substring(4, (8) - (4))); SupportClass.Tokenizer tok = new SupportClass.Tokenizer(message.Substring(4), System.Convert.ToString(new char[] { fieldSep, ourSegmentSeparator }), true); System.String[] mshFields = getMSHFields(tok, fieldSep); System.Object[] structure = getStructure(mshFields[8], ec.ComponentSeparator); StructRef root = (StructRef)myEventGuideMap[structure[0]]; if (root == null) { result = myPipeParser.parse(message); } else { int csIndex = mshFields[11].IndexOf((System.Char)ec.ComponentSeparator); result = instantiateMessage((System.String)structure[1], version, ((System.Boolean)structure[2])); StructRef mshRef = null; lock (root) { mshRef = root.getSuccessor("MSH"); root.reset(); } Segment msh = (Segment)result.get_Renamed("MSH"); for (int i = 0; i < mshRef.Fields.Length; i++) { int fieldNum = mshRef.Fields[i]; parse(mshFields[fieldNum - 1], msh, fieldNum, ec); } parse(tok, result, root, ec); } return(result); }
/// /// <summary> * add - adds a integer list string to the existing integer list /// * </summary> /// * <param name="s"> the given string /// * </param> /// * <exception cref="FormatException"> - if the String has not a valid format </exception> /// public virtual void Add(string s) { //StringTokenizer sToken = new StringTokenizer(s, JDFConstants.BLANK); SupportClass.Tokenizer sToken = new SupportClass.Tokenizer(s, JDFConstants.BLANK); ArrayList numList = m_numList; while (sToken.HasMoreTokens()) { int i = StringUtil.parseInt(sToken.NextToken(), 0); try { numList.Add(i); } catch (FormatException) { throw new FormatException("Data format exception!"); } } }
/// <summary> <p>A convenience method for registering applications (using <code>registerApplication() /// </code>) with this service. Information about which Applications should handle which /// messages is read from the given text file. Each line in the file should have the /// following format (entries tab delimited):</p> /// <p>message_type 	 trigger_event 	 application_class</p> /// <p>message_type 	 trigger_event 	 application_class</p> /// <p>Note that message type and event can be the wildcard "*", which means any.</p> /// <p>For example, if you write an Application called org.yourorganiztion.ADTProcessor /// that processes several types of ADT messages, and another called /// org.yourorganization.ResultProcessor that processes result messages, you might have a /// file that looks like this: </p> /// <p>ADT 	 * 	 org.yourorganization.ADTProcessor<br> /// ORU 	 R01 	 org.yourorganization.ResultProcessor</p> /// <p>Each class listed in this file must implement Application and must have a zero-argument /// constructor.</p> /// </summary> public virtual void loadApplicationsFromFile(System.IO.FileInfo f) { System.IO.StreamReader in_Renamed = new System.IO.StreamReader(new System.IO.StreamReader(f.FullName, System.Text.Encoding.Default).BaseStream, new System.IO.StreamReader(f.FullName, System.Text.Encoding.Default).CurrentEncoding); System.String line = null; while ((line = in_Renamed.ReadLine()) != null) { //parse application registration information SupportClass.Tokenizer tok = new SupportClass.Tokenizer(line, "\t", false); System.String type = null, event_Renamed = null, className = null; if (tok.HasMoreTokens()) { //skip blank lines try { type = tok.NextToken(); event_Renamed = tok.NextToken(); className = tok.NextToken(); } catch (System.ArgumentOutOfRangeException) { throw new NuGenHL7Exception("Can't register applications from file " + f.Name + ". The line '" + line + "' is not of the form: message_type [tab] trigger_event [tab] application_class.", NuGenHL7Exception.APPLICATION_INTERNAL_ERROR); } System.Type appClass = System.Type.GetType(className); //may throw ClassNotFoundException System.Object appObject = System.Activator.CreateInstance(appClass); NuGenApplication app = null; try { app = (NuGenApplication)appObject; } catch (System.InvalidCastException) { throw new NuGenHL7Exception("The specified class, " + appClass.FullName + ", doesn't implement Application.", NuGenHL7Exception.APPLICATION_INTERNAL_ERROR); } this.registerApplication(type, event_Renamed, app); } } }
public override void characterData(CMLStack xpath, char[] ch, int start, int length) { System.String s = new System.String(ch, start, length).Trim(); if (isELSYM) { elsym.Add(s); } else if (isBond) { //logger.debug("CD (bond): " + s); if (connect_root.Length > 0) { SupportClass.Tokenizer st = new SupportClass.Tokenizer(s); while (st.HasMoreTokens()) { System.String atom = (System.String)st.NextToken(); if (!atom.Equals("0")) { //logger.debug("new bond: " + connect_root + "-" + atom); cdo.startObject("Bond"); int atom1 = System.Int32.Parse(connect_root) - 1; int atom2 = System.Int32.Parse(atom) - 1; cdo.setObjectProperty("Bond", "atom1", ((System.Int32)atom1).ToString()); cdo.setObjectProperty("Bond", "atom2", ((System.Int32)atom2).ToString()); cdo.setObjectProperty("Bond", "order", "1"); cdo.endObject("Bond"); } } } } else { base.characterData(xpath, ch, start, length); } }
/// <summary> Description of the Method /// /// </summary> /// <param name="value"> Description of the Parameter /// </param> /// <returns> Description of the Return Value /// </returns> public static Player fromString(System.String value_Renamed) { // System.out.println("."+value+"."); try { Player player = new Player(); SupportClass.Tokenizer st = new SupportClass.Tokenizer(value_Renamed, "\t"); player.FullName = st.NextToken(); player.Rating = System.Int32.Parse(st.NextToken()); player.QuickRating = System.Int32.Parse(st.NextToken()); player.MemberNumber = st.NextToken(); player.Expires = st.NextToken(); player.State = st.NextToken(); return(player); } catch (System.Exception e) { System.Console.Out.WriteLine(value_Renamed); SupportClass.WriteStackTrace(e, Console.Error); return(null); } }
/// <summary> Extracts the subtypes from the specified attribute name. /// /// For example, if the attribute name is cn;lang-ja;phonetic, /// this method returns an array containing lang-ja and phonetic. /// /// </summary> /// <param name="attrName"> Name of the attribute from which to extract /// the subtypes. /// /// </param> /// <returns> An array subtypes or null if the attribute has none. /// /// @throws IllegalArgumentException if attrName is null /// </returns> public static string[] getSubtypes(string attrName) { if ((object)attrName == null) { throw new ArgumentException("Attribute name cannot be null"); } SupportClass.Tokenizer st = new SupportClass.Tokenizer(attrName, ";"); string[] subTypes = null; int cnt = st.Count; if (cnt > 0) { st.NextToken(); // skip over basename subTypes = new string[cnt - 1]; int i = 0; while (st.HasMoreTokens()) { subTypes[i++] = st.NextToken(); } } return(subTypes); }
private void ProcessResponse() { SupportClass.Tokenizer tokens = new SupportClass.Tokenizer(begin, " \r\t"); try { version = tokens.NextToken(); status = Int32.Parse(tokens.NextToken()); if (tokens.HasMoreTokens()) { reason = tokens.NextToken(); } else { reason = ""; } } catch { throw new IOException("Failed to parse HTTP response \"" + begin + "\""); } }
/// <summary>Gets path information from a path spec. </summary> private PathSpec parsePathSpec(System.String spec) { PathSpec ps = new PathSpec(this); if (spec.StartsWith(".")) { ps.find = true; spec = spec.Substring(1); } else { ps.find = false; } if (spec.Length == 0) { throw new NuGenHL7Exception("Invalid path (some path element is either empty or contains only a dot)"); } SupportClass.Tokenizer tok = new SupportClass.Tokenizer(spec, "()", false); ps.pattern = tok.NextToken(); if (tok.HasMoreTokens()) { System.String repString = tok.NextToken(); try { ps.rep = System.Int32.Parse(repString); } catch (System.FormatException) { throw new NuGenHL7Exception(repString + " is not a valid rep #", NuGenHL7Exception.APPLICATION_INTERNAL_ERROR); } } else { ps.rep = 0; } return(ps); }
private void parse(System.String field, Segment segment, int num, NuGenEncodingCharacters ec) { if (field != null) { int rep = 0; int component = 1; int subcomponent = 1; Type type = segment.getField(num, rep); System.String delim = System.Convert.ToString(new char[] { ec.RepetitionSeparator, ec.ComponentSeparator, ec.SubcomponentSeparator }); for (SupportClass.Tokenizer tok = new SupportClass.Tokenizer(field, delim, true); tok.HasMoreTokens();) { System.String token = tok.NextToken(); char c = token[0]; if (c == ec.RepetitionSeparator) { rep++; component = 1; subcomponent = 1; type = segment.getField(num, rep); } else if (c == ec.ComponentSeparator) { component++; subcomponent = 1; } else if (c == ec.SubcomponentSeparator) { subcomponent++; } else { Primitive p = Terser.getPrimitive(type, component, subcomponent); p.Value = token; } } } }
/// /// <summary> * /// * constructs a VString by tokenizing a string </summary> /// * <param name="strIn"> the string to tokenize </param> /// * <param name="strSep"> the separator character </param> /// public VString(string strIn, string strSep) : base() { this.Clear(); string strSepLocal = strSep; if (strIn != null) { if (strSepLocal == null) { strSepLocal = JDFConstants.BLANK; } //StringTokenizer sToken = new StringTokenizer (strIn, strSepLocal); SupportClass.Tokenizer sToken = new SupportClass.Tokenizer(strIn, strSepLocal); while (sToken.HasMoreTokens()) { this.Add(sToken.NextToken()); } } }
private System.String getMolName(System.String line) { if (line == null) { return(""); } SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " "); int ntok = st.Count; System.String[] toks = new System.String[ntok]; for (int j = 0; j < ntok; j++) { toks[j] = st.NextToken(); } if (toks.Length == 3) { return(toks[2]); } else { return(""); } }
} //end method /// <summary> Checks a code for an exact match, and using certain sequences where some /// characters are wildcards (e.g. HL7nnnn). If the pattern contains one of /// " or ", " OR ", or "," each operand is checked. /// </summary> private bool checkCode(System.String code, System.String pattern) { bool match = false; //mod by Neal acharya - Do full match on with the pattern. If code matches pattern then return true //else parse pattern to look for wildcard characters if (code.Equals(pattern)) { match = true; } //end if else { if (pattern.IndexOf(' ') >= 0 || pattern.IndexOf(',') >= 0) { SupportClass.Tokenizer tok = new SupportClass.Tokenizer(pattern, ", ", false); while (tok.HasMoreTokens() && !match) { System.String t = tok.NextToken(); if (!t.ToUpper().Equals("or".ToUpper())) { match = checkCode(code, t); } } //end while } //end if else { if (code.Equals(pattern)) { match = true; } } //end else } //end else return(match); } //end method
/// /// <summary> * add - adds a x and a y coordinate to the vector /// * </summary> /// * <param name="s"> a string with the x and y coordinate to add /// * </param> /// * <exception cref="FormatException"> - if the String has not a valid format </exception> /// public virtual void add(string s) { //StringTokenizer sToken = new StringTokenizer(s, JDFConstants.BLANK); SupportClass.Tokenizer sToken = new SupportClass.Tokenizer(s, JDFConstants.BLANK); if ((sToken.Count % 2) != 0) { throw new FormatException("Data format exception!"); } while (sToken.HasMoreTokens()) { string t = sToken.NextToken().Trim(); try { m_numList.Add(t); // (new double(t)); } catch (FormatException) { throw new FormatException("Data format exception!"); } } }
/// /// <summary> * isValid - validates the given String /// * </summary> /// * <param name="s"> the given string /// * </param> /// * <exception cref="FormatException"> - if the String has not a valid format </exception> /// protected internal virtual void isValid(string s) { VString vs = new VString(); //StringTokenizer sToken = new StringTokenizer(s, "~"); SupportClass.Tokenizer sToken = new SupportClass.Tokenizer(s, "~"); while (sToken.HasMoreTokens()) { string str = sToken.NextToken(); vs.Add(str.Trim()); } Left = vs[0]; if (vs.Count == 2) { Right = vs[1]; } else { Right = vs[0]; } }
private static void predict(System.IO.StreamReader input, System.IO.BinaryWriter output, svm_model model, int predict_probability) { int correct = 0; int total = 0; double error = 0; double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0; int svm_type = svm.svm_get_svm_type(model); int nr_class = svm.svm_get_nr_class(model); int[] labels = new int[nr_class]; double[] prob_estimates = null; if (predict_probability == 1) { if (svm_type == svm_parameter.EPSILON_SVR || svm_type == svm_parameter.NU_SVR) { System.Console.Out.Write("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=" + svm.svm_get_svr_probability(model) + "\n"); } else { svm.svm_get_labels(model, labels); prob_estimates = new double[nr_class]; //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("labels"); for (int j = 0; j < nr_class; j++) { //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(" " + labels[j]); } //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("\n"); } } while (true) { System.String line = input.ReadLine(); if ((System.Object) line == null) break; SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " \t\n\r\f:"); double target = atof(st.NextToken()); int m = st.Count / 2; svm_node[] x = new svm_node[m]; for (int j = 0; j < m; j++) { x[j] = new svm_node(); x[j].index = atoi(st.NextToken()); x[j].value_Renamed = atof(st.NextToken()); } double v; if (predict_probability == 1 && (svm_type == svm_parameter.C_SVC || svm_type == svm_parameter.NU_SVC)) { v = svm.svm_predict_probability(model, x, prob_estimates); //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(v + " "); for (int j = 0; j < nr_class; j++) { //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(prob_estimates[j] + " "); } //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("\n"); } else { v = svm.svm_predict(model, x); //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(v + "\n"); } if (v == target) ++correct; error += (v - target) * (v - target); sumv += v; sumy += target; sumvv += v * v; sumyy += target * target; sumvy += v * target; ++total; } System.Console.Out.Write("Accuracy = " + (double) correct / total * 100 + "% (" + correct + "/" + total + ") (classification)\n"); System.Console.Out.Write("Mean squared error = " + error / total + " (regression)\n"); System.Console.Out.Write("Squared correlation coefficient = " + ((total * sumvy - sumv * sumy) * (total * sumvy - sumv * sumy)) / ((total * sumvv - sumv * sumv) * (total * sumyy - sumy * sumy)) + " (regression)\n"); }
/// <summary> RFC 2254 filter helper method. Will Parse a filter component.</summary> private Asn1Tagged parseFilterComp() { Asn1Tagged tag = null; int filterComp = ft.OpOrAttr; switch (filterComp) { case AND: case OR: tag = new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, true, filterComp), parseFilterList(), false); break; case NOT: tag = new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, true, filterComp), parseFilter(), true); break; default: int filterType = ft.FilterType; System.String value_Renamed = ft.Value; switch (filterType) { case GREATER_OR_EQUAL: case LESS_OR_EQUAL: case APPROX_MATCH: tag = new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, true, filterType), new RfcAttributeValueAssertion(new RfcAttributeDescription(ft.Attr), new RfcAssertionValue(unescapeString(value_Renamed))), false); break; case EQUALITY_MATCH: if (value_Renamed.Equals("*")) { // present tag = new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, false, PRESENT), new RfcAttributeDescription(ft.Attr), false); } else if (value_Renamed.IndexOf((System.Char) '*') != - 1) { // substrings parse: // [initial], *any*, [final] into an Asn1SequenceOf SupportClass.Tokenizer sub = new SupportClass.Tokenizer(value_Renamed, "*", true); // SupportClass.Tokenizer sub = new SupportClass.Tokenizer(value_Renamed, "*");//, true); Asn1SequenceOf seq = new Asn1SequenceOf(5); int tokCnt = sub.Count; int cnt = 0; System.String lastTok = new System.Text.StringBuilder("").ToString(); while (sub.HasMoreTokens()) { System.String subTok = sub.NextToken(); cnt++; if (subTok.Equals("*")) { // if previous token was '*', and since the current // token is a '*', we need to insert 'any' if (lastTok.Equals(subTok)) { // '**' seq.add(new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, false, ANY), new RfcLdapString(unescapeString("")), false)); } } else { // value (RfcLdapString) if (cnt == 1) { // initial seq.add(new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, false, INITIAL), new RfcLdapString(unescapeString(subTok)), false)); } else if (cnt < tokCnt) { // any seq.add(new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, false, ANY), new RfcLdapString(unescapeString(subTok)), false)); } else { // final seq.add(new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, false, FINAL), new RfcLdapString(unescapeString(subTok)), false)); } } lastTok = subTok; } tag = new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, true, SUBSTRINGS), new RfcSubstringFilter(new RfcAttributeDescription(ft.Attr), seq), false); } else { // simple tag = new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, true, EQUALITY_MATCH), new RfcAttributeValueAssertion(new RfcAttributeDescription(ft.Attr), new RfcAssertionValue(unescapeString(value_Renamed))), false); } break; case EXTENSIBLE_MATCH: System.String type = null, matchingRule = null; bool dnAttributes = false; // SupportClass.Tokenizer st = new StringTokenizer(ft.Attr, ":", true); SupportClass.Tokenizer st = new SupportClass.Tokenizer(ft.Attr, ":");//, true); bool first = true; while (st.HasMoreTokens()) { System.String s = st.NextToken().Trim(); if (first && !s.Equals(":")) { type = s; } // dn must be lower case to be considered dn of the Entry. else if (s.Equals("dn")) { dnAttributes = true; } else if (!s.Equals(":")) { matchingRule = s; } first = false; } tag = new Asn1Tagged(new Asn1Identifier(Asn1Identifier.CONTEXT, true, EXTENSIBLE_MATCH), new RfcMatchingRuleAssertion(((System.Object) matchingRule == null)?null:new RfcMatchingRuleId(matchingRule), ((System.Object) type == null)?null:new RfcAttributeDescription(type), new RfcAssertionValue(unescapeString(value_Renamed)), (dnAttributes == false)?null:new Asn1Boolean(true)), false); break; } break; } return tag; }
internal static System.String determineAtomSetCollectionReader(System.IO.StreamReader bufferedReader) { System.String[] lines = new System.String[4]; LimitedLineReader llr = new LimitedLineReader(bufferedReader, 16384); for (int i = 0; i < lines.Length; ++i) { lines[i] = llr.readLineWithNewline(); } if (lines[3].Length >= 6) { System.String line4trimmed = lines[3].Trim(); if (line4trimmed.EndsWith("V2000") || line4trimmed.EndsWith("v2000") || line4trimmed.EndsWith("V3000")) { return("Mol"); } try { System.Int32.Parse(lines[3].Substring(0, (3) - (0)).Trim()); System.Int32.Parse(lines[3].Substring(3, (6) - (3)).Trim()); return("Mol"); } catch (System.FormatException nfe) { } } try { /*int atomCount = */ System.Int32.Parse(lines[0].Trim()); return("Xyz"); } catch (System.FormatException e) { } try { SupportClass.Tokenizer tokens = new SupportClass.Tokenizer(lines[0].Trim(), " \t"); if ((tokens != null) && (tokens.Count >= 2)) { System.Int32.Parse(tokens.NextToken().Trim()); return("FoldingXyz"); } } catch (System.FormatException e) { // } // run these loops forward ... easier for people to understand for (int i = 0; i < startsWithRecords.Length; ++i) { System.String[] recordTags = startsWithRecords[i]; for (int j = 0; j < recordTags.Length; ++j) { System.String recordTag = recordTags[j]; for (int k = 0; k < lines.Length; ++k) { if (lines[k].StartsWith(recordTag)) { return(startsWithFormats[i]); } } } } for (int i = 0; i < containsRecords.Length; ++i) { System.String[] recordTags = containsRecords[i]; for (int j = 0; j < recordTags.Length; ++j) { System.String recordTag = recordTags[j]; for (int k = 0; k < lines.Length; ++k) { if (lines[k].IndexOf(recordTag) != -1) { return(containsFormats[i]); } } } } if (lines[1] == null || lines[1].Trim().Length == 0) { return("Jme"); // this is really quite broken :-) } return(null); }
/// <summary> Reads a text based configuration file. /// /// </summary> /// <param name="builder">IChemObjectBuilder used to construct the IAtomType's. /// </param> /// <throws> IOException when a problem occured with reading from the InputStream </throws> /// <returns> A Vector with read IAtomType's. /// </returns> public virtual System.Collections.ArrayList readAtomTypes(IChemObjectBuilder builder) { System.Collections.ArrayList atomTypes = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); if (ins == null) { // trying the default //System.out.println("readAtomTypes getResourceAsStream:" // + configFile); //UPGRADE_ISSUE: Method 'java.lang.ClassLoader.getResourceAsStream' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javalangClassLoader'" //UPGRADE_ISSUE: Method 'java.lang.Class.getClassLoader' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javalangClassgetClassLoader'" ins = Assembly.GetExecutingAssembly().GetManifestResourceStream("NuGenCDKSharp." + configFile); } if (ins == null) { throw new System.IO.IOException("There was a problem getting the default stream: " + configFile); } // read the contents from file //UPGRADE_TODO: The differences in the expected value of parameters for constructor 'java.io.BufferedReader.BufferedReader' may cause compilation errors. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1092'" //UPGRADE_WARNING: At least one expression was used more than once in the target code. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1181'" System.IO.StreamReader reader = new System.IO.StreamReader(new System.IO.StreamReader(ins, System.Text.Encoding.Default).BaseStream, new System.IO.StreamReader(ins, System.Text.Encoding.Default).CurrentEncoding, false, 1024); SupportClass.Tokenizer tokenizer; System.String string_Renamed; while (true) { string_Renamed = reader.ReadLine(); if (string_Renamed == null) { break; } if (!string_Renamed.StartsWith("#")) { System.String name = ""; System.String rootType = ""; int atomicNumber = 0, colorR = 0, colorG = 0, colorB = 0; double mass = 0.0, vdwaals = 0.0, covalent = 0.0; tokenizer = new SupportClass.Tokenizer(string_Renamed, "\t ,;"); int tokenCount = tokenizer.Count; if (tokenCount == 9) { name = tokenizer.NextToken(); rootType = tokenizer.NextToken(); System.String san = tokenizer.NextToken(); System.String sam = tokenizer.NextToken(); System.String svdwaals = tokenizer.NextToken(); System.String scovalent = tokenizer.NextToken(); System.String sColorR = tokenizer.NextToken(); System.String sColorG = tokenizer.NextToken(); System.String sColorB = tokenizer.NextToken(); try { //UPGRADE_TODO: The differences in the format of parameters for constructor 'java.lang.Double.Double' may cause compilation errors. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1092'" mass = System.Double.Parse(sam); //UPGRADE_TODO: The differences in the format of parameters for constructor 'java.lang.Double.Double' may cause compilation errors. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1092'" vdwaals = System.Double.Parse(svdwaals); //UPGRADE_TODO: The differences in the format of parameters for constructor 'java.lang.Double.Double' may cause compilation errors. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1092'" covalent = System.Double.Parse(scovalent); atomicNumber = System.Int32.Parse(san); colorR = System.Int32.Parse(sColorR); colorG = System.Int32.Parse(sColorG); colorB = System.Int32.Parse(sColorB); } catch (System.FormatException nfe) { throw new System.IO.IOException("AtomTypeTable.ReadAtypes: " + "Malformed Number"); } IAtomType atomType = builder.newAtomType(name, rootType); atomType.AtomicNumber = atomicNumber; atomType.setExactMass(mass); atomType.VanderwaalsRadius = vdwaals; atomType.CovalentRadius = covalent; System.Drawing.Color color = System.Drawing.Color.FromArgb(colorR, colorG, colorB); atomType.setProperty("org.openscience.cdk.renderer.color", color); atomTypes.Add(atomType); } else { throw new System.IO.IOException("AtomTypeTable.ReadAtypes: " + "Wrong Number of fields"); } } } // end while ins.Close(); return(atomTypes); }
/// <summary> Constructs a new 'QuantTypeSpec' for the specified number of components /// and tiles and the arguments of "-Qtype" option. This constructor is /// called by the encoder. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">the type of the specification module i.e. tile specific, /// component specific or both. /// /// </param> /// <param name="pl">The ParameterList /// /// </param> public QuantTypeSpec(int nt, int nc, byte type, ParameterList pl):base(nt, nc, type) { System.String param = pl.getParameter("Qtype"); if (param == null) { if (pl.getBooleanParameter("lossless")) { setDefault("reversible"); } else { setDefault("expounded"); } return ; } // Parse argument SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); System.String word; // current word byte curSpecValType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification while (stk.HasMoreTokens()) { word = stk.NextToken().ToLower(); switch (word[0]) { case 't': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecValType == SPEC_COMP_DEF) { curSpecValType = SPEC_TILE_COMP; } else { curSpecValType = SPEC_TILE_DEF; } break; case 'c': // Components specification compSpec = parseIdx(word, nComp); if (curSpecValType == SPEC_TILE_DEF) { curSpecValType = SPEC_TILE_COMP; } else { curSpecValType = SPEC_COMP_DEF; } break; case 'r': // reversible specification case 'd': // derived quantization step size specification case 'e': // expounded quantization step size specification if (!word.ToUpper().Equals("reversible".ToUpper()) && !word.ToUpper().Equals("derived".ToUpper()) && !word.ToUpper().Equals("expounded".ToUpper())) { throw new System.ArgumentException("Unknown parameter " + "for " + "'-Qtype' option: " + word); } if (pl.getBooleanParameter("lossless") && (word.ToUpper().Equals("derived".ToUpper()) || word.ToUpper().Equals("expounded".ToUpper()))) { throw new System.ArgumentException("Cannot use non " + "reversible " + "quantization with " + "'-lossless' option"); } if (curSpecValType == SPEC_DEF) { // Default specification setDefault(word); } else if (curSpecValType == SPEC_TILE_DEF) { // Tile default specification for (int i = tileSpec.Length - 1; i >= 0; i--) { if (tileSpec[i]) { setTileDef(i, word); } } } else if (curSpecValType == SPEC_COMP_DEF) { // Component default specification for (int i = compSpec.Length - 1; i >= 0; i--) if (compSpec[i]) { setCompDef(i, word); } } else { // Tile-component specification for (int i = tileSpec.Length - 1; i >= 0; i--) { for (int j = compSpec.Length - 1; j >= 0; j--) { if (tileSpec[i] && compSpec[j]) { setTileCompVal(i, j, word); } } } } // Re-initialize curSpecValType = SPEC_DEF; tileSpec = null; compSpec = null; break; default: throw new System.ArgumentException("Unknown parameter for " + "'-Qtype' option: " + word); } } // Check that default value has been specified if (getDefault() == null) { int ndefspec = 0; for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { if (specValType[t][c] == SPEC_DEF) { ndefspec++; } } } // If some tile-component have received no specification, the // quantization type is 'reversible' (if '-lossless' is specified) // or 'expounded' (if not). if (ndefspec != 0) { if (pl.getBooleanParameter("lossless")) { setDefault("reversible"); } else { setDefault("expounded"); } } else { // All tile-component have been specified, takes arbitrarily // the first tile-component value as default and modifies the // specification type of all tile-component sharing this // value. setDefault(getTileCompVal(0, 0)); switch (specValType[0][0]) { case SPEC_TILE_DEF: for (int c = nc - 1; c >= 0; c--) { if (specValType[0][c] == SPEC_TILE_DEF) specValType[0][c] = SPEC_DEF; } tileDef[0] = null; break; case SPEC_COMP_DEF: for (int t = nt - 1; t >= 0; t--) { if (specValType[t][0] == SPEC_COMP_DEF) specValType[t][0] = SPEC_DEF; } compDef[0] = null; break; case SPEC_TILE_COMP: specValType[0][0] = SPEC_DEF; tileCompVal["t0c0"] = null; break; } } } }
/// <summary> Read a Reaction from a file in MDL RXN format /// /// </summary> /// <returns> The Reaction that was read from the MDL file. /// </returns> private IMolecule readMolecule(IMolecule molecule) { AtomTypeFactory atFactory = null; try { atFactory = AtomTypeFactory.getInstance("mol2_atomtypes.xml", molecule.Builder); } catch (System.Exception exception) { System.String error = "Could not instantiate an AtomTypeFactory"; //logger.error(error); //logger.debug(exception); throw new CDKException(error, exception); } try { System.String line = input.ReadLine(); int atomCount = 0; int bondCount = 0; while (line != null) { if (line.StartsWith("@<TRIPOS>MOLECULE")) { //logger.info("Reading molecule block"); // second line has atom/bond counts? input.ReadLine(); // disregard the name line System.String counts = input.ReadLine(); SupportClass.Tokenizer tokenizer = new SupportClass.Tokenizer(counts); try { atomCount = System.Int32.Parse(tokenizer.NextToken()); } catch (System.FormatException nfExc) { System.String error = "Error while reading atom count from MOLECULE block"; //logger.error(error); //logger.debug(nfExc); throw new CDKException(error, nfExc); } if (tokenizer.HasMoreTokens()) { try { bondCount = System.Int32.Parse(tokenizer.NextToken()); } catch (System.FormatException nfExc) { System.String error = "Error while reading atom and bond counts"; //logger.error(error); //logger.debug(nfExc); throw new CDKException(error, nfExc); } } else { bondCount = 0; } //logger.info("Reading #atoms: ", atomCount); //logger.info("Reading #bonds: ", bondCount); //logger.warn("Not reading molecule qualifiers"); } else if (line.StartsWith("@<TRIPOS>ATOM")) { //logger.info("Reading atom block"); for (int i = 0; i < atomCount; i++) { line = input.ReadLine().Trim(); SupportClass.Tokenizer tokenizer = new SupportClass.Tokenizer(line); tokenizer.NextToken(); // disregard the id token System.String nameStr = tokenizer.NextToken(); System.String xStr = tokenizer.NextToken(); System.String yStr = tokenizer.NextToken(); System.String zStr = tokenizer.NextToken(); System.String atomTypeStr = tokenizer.NextToken(); IAtomType atomType = atFactory.getAtomType(atomTypeStr); if (atomType == null) { atomType = atFactory.getAtomType("X"); //logger.error("Could not find specified atom type: ", atomTypeStr); } IAtom atom = molecule.Builder.newAtom("X"); atom.ID = nameStr; atom.AtomTypeName = atomTypeStr; atFactory.configure(atom); try { double x = System.Double.Parse(xStr); double y = System.Double.Parse(yStr); double z = System.Double.Parse(zStr); atom.setPoint3d(new Point3d(x, y, z)); } catch (System.FormatException nfExc) { System.String error = "Error while reading atom coordinates"; //logger.error(error); //logger.debug(nfExc); throw new CDKException(error, nfExc); } molecule.addAtom(atom); } } else if (line.StartsWith("@<TRIPOS>BOND")) { //logger.info("Reading bond block"); for (int i = 0; i < bondCount; i++) { line = input.ReadLine(); SupportClass.Tokenizer tokenizer = new SupportClass.Tokenizer(line); tokenizer.NextToken(); // disregard the id token System.String atom1Str = tokenizer.NextToken(); System.String atom2Str = tokenizer.NextToken(); System.String orderStr = tokenizer.NextToken(); try { int atom1 = System.Int32.Parse(atom1Str); int atom2 = System.Int32.Parse(atom2Str); double order = 0; if ("1".Equals(orderStr)) { order = CDKConstants.BONDORDER_AROMATIC; } else if ("2".Equals(orderStr)) { order = CDKConstants.BONDORDER_DOUBLE; } else if ("3".Equals(orderStr)) { order = CDKConstants.BONDORDER_TRIPLE; } else if ("am".Equals(orderStr)) { order = CDKConstants.BONDORDER_SINGLE; } else if ("ar".Equals(orderStr)) { order = CDKConstants.BONDORDER_AROMATIC; } else if ("du".Equals(orderStr)) { order = CDKConstants.BONDORDER_SINGLE; } else if ("un".Equals(orderStr)) { order = CDKConstants.BONDORDER_SINGLE; } else if ("nc".Equals(orderStr)) { // not connected order = 0; } if (order != 0) { molecule.addBond(atom1 - 1, atom2 - 1, order); } } catch (System.FormatException nfExc) { System.String error = "Error while reading bond information"; //logger.error(error); //logger.debug(nfExc); throw new CDKException(error, nfExc); } } } line = input.ReadLine(); } } catch (System.IO.IOException exception) { System.String error = "Error while reading general structure"; //logger.error(error); //logger.debug(exception); throw new CDKException(error, exception); } return(molecule); }
/// <summary> Constructs a new 'IntegerSpec' for the specified number of tiles and /// components, the allowed specifications type and the ParameterList /// instance. This constructor is normally called at encoder side and parse /// arguments of specified option. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">The allowed specifications type /// /// </param> /// <param name="pl">The ParameterList instance /// /// </param> /// <param name="optName">The name of the option to process /// /// </param> public IntegerSpec(int nt, int nc, byte type, ParameterList pl, System.String optName):base(nt, nc, type) { System.Int32 value_Renamed; System.String param = pl.getParameter(optName); if (param == null) { // No parameter specified param = pl.DefaultParameterList.getParameter(optName); try { setDefault((System.Object) System.Int32.Parse(param)); } catch (System.FormatException) { throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + param); } return ; } // Parse argument SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); System.String word; // current word byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification while (stk.HasMoreTokens()) { word = stk.NextToken(); switch (word[0]) { case 't': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_TILE_DEF; } break; case 'c': // Components specification compSpec = parseIdx(word, nComp); if (curSpecType == SPEC_TILE_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_COMP_DEF; } break; default: try { value_Renamed = System.Int32.Parse(word); } catch (System.FormatException) { throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + word); } if (curSpecType == SPEC_DEF) { setDefault((System.Object) value_Renamed); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) if (tileSpec[i]) { setTileDef(i, (System.Object) value_Renamed); } } else if (curSpecType == SPEC_COMP_DEF) { for (int i = compSpec.Length - 1; i >= 0; i--) if (compSpec[i]) { setCompDef(i, (System.Object) value_Renamed); } } else { for (int i = tileSpec.Length - 1; i >= 0; i--) { for (int j = compSpec.Length - 1; j >= 0; j--) { if (tileSpec[i] && compSpec[j]) { setTileCompVal(i, j, (System.Object) value_Renamed); } } } } // Re-initialize curSpecType = SPEC_DEF; tileSpec = null; compSpec = null; break; } } // Check that default value has been specified if (getDefault() == null) { int ndefspec = 0; for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { if (specValType[t][c] == SPEC_DEF) { ndefspec++; } } } // If some tile-component have received no specification, it takes // the default value defined in ParameterList if (ndefspec != 0) { param = pl.DefaultParameterList.getParameter(optName); try { setDefault((System.Object) System.Int32.Parse(param)); } catch (System.FormatException) { throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + param); } } else { // All tile-component have been specified, takes the first // tile-component value as default. setDefault(getTileCompVal(0, 0)); switch (specValType[0][0]) { case SPEC_TILE_DEF: for (int c = nc - 1; c >= 0; c--) { if (specValType[0][c] == SPEC_TILE_DEF) specValType[0][c] = SPEC_DEF; } tileDef[0] = null; break; case SPEC_COMP_DEF: for (int t = nt - 1; t >= 0; t--) { if (specValType[t][0] == SPEC_COMP_DEF) specValType[t][0] = SPEC_DEF; } compDef[0] = null; break; case SPEC_TILE_COMP: specValType[0][0] = SPEC_DEF; tileCompVal["t0c0"] = null; break; } } } }
/// <summary> Returns a String representing the encoding of the given message, if /// the encoding is recognized. For example if the given message appears /// to be encoded using HL7 2.x XML rules then "XML" would be returned. /// If the encoding is not recognized then null is returned. That this /// method returns a specific encoding does not guarantee that the /// message is correctly encoded (e.g. well formed XML) - just that /// it is not encoded using any other encoding than the one returned. /// </summary> public override System.String getEncoding(System.String message) { System.String encoding = null; //quit if the string is too short if (message.Length < 4) return null; //see if it looks like this message is | encoded ... bool ok = true; //string should start with "MSH" if (!message.StartsWith("MSH")) return null; //4th character of each segment should be field delimiter char fourthChar = message[3]; SupportClass.Tokenizer st = new SupportClass.Tokenizer(message, System.Convert.ToString(segDelim), false); while (st.HasMoreTokens()) { System.String x = st.NextToken(); if (x.Length > 0) { if (System.Char.IsWhiteSpace(x[0])) x = stripLeadingWhitespace(x); if (x.Length >= 4 && x[3] != fourthChar) return null; } } //should be at least 11 field delimiters (because MSH-12 is required) int nextFieldDelimLoc = 0; for (int i = 0; i < 11; i++) { nextFieldDelimLoc = message.IndexOf((System.Char) fourthChar, nextFieldDelimLoc + 1); if (nextFieldDelimLoc < 0) return null; } if (ok) encoding = "VB"; return encoding; }
/// <summary> Creates a new PGX file reader from the specified File object. /// /// </summary> /// <param name="in">The input file as File object. /// /// </param> /// <exception cref="IOException">If an I/O error occurs. /// /// </exception> public ImgReaderPGX(System.IO.FileInfo in_Renamed) { System.String header; // Check if specified file exists bool tmpBool; if (System.IO.File.Exists(in_Renamed.FullName)) tmpBool = true; else tmpBool = System.IO.Directory.Exists(in_Renamed.FullName); if (!tmpBool) { throw new System.ArgumentException("PGX file " + in_Renamed.Name + " does not exist"); } //Opens the given file this.in_Renamed = SupportClass.RandomAccessFileSupport.CreateRandomAccessFile(in_Renamed, "r"); try { System.IO.StreamReader in_reader = new System.IO.StreamReader(this.in_Renamed); //UPGRADE_ISSUE: Method 'java.io.RandomAccessFile.readLine' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javaioRandomAccessFilereadLine'" header = in_reader.ReadLine(); } catch (System.IO.IOException) { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } if (header == null) { throw new System.IO.IOException(in_Renamed.Name + " is an empty file"); } offset = (header.Length + 1); //Get informations from header SupportClass.Tokenizer st = new SupportClass.Tokenizer(header); try { int nTokens = st.Count; // Magic Number if (!(st.NextToken()).Equals("PG")) throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); // Endianess System.String tmp = st.NextToken(); if (tmp.Equals("LM")) byteOrder = CSJ2K.j2k.io.EndianType_Fields.LITTLE_ENDIAN; else if (tmp.Equals("ML")) byteOrder = CSJ2K.j2k.io.EndianType_Fields.BIG_ENDIAN; else throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); // Unsigned/signed if present in the header if (nTokens == 6) { tmp = st.NextToken(); if (tmp.Equals("+")) isSigned = false; else if (tmp.Equals("-")) isSigned = true; else throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } // bit-depth, width, height try { bitDepth = (System.Int32.Parse(st.NextToken())); // bitDepth must be between 1 and 31 if ((bitDepth <= 0) || (bitDepth > 31)) throw new System.IO.IOException(in_Renamed.Name + " is not a valid PGX file"); w = (System.Int32.Parse(st.NextToken())); h = (System.Int32.Parse(st.NextToken())); } catch (System.FormatException) { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } } catch (System.ArgumentOutOfRangeException) { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } // Number of component nc = 1; // Number of bytes per data if (bitDepth <= 8) packBytes = 1; else if (bitDepth <= 16) packBytes = 2; // <= 31 else packBytes = 4; }
/// <summary> Splits the given composite string into an array of components using the given /// delimiter. /// </summary> public static System.String[] split(System.String composite, System.String delim) { System.Collections.ArrayList components = new System.Collections.ArrayList(); //defend against evil nulls if (composite == null) composite = ""; if (delim == null) delim = ""; SupportClass.Tokenizer tok = new SupportClass.Tokenizer(composite, delim, true); bool previousTokenWasDelim = true; while (tok.HasMoreTokens()) { System.String thisTok = tok.NextToken(); if (thisTok.Equals(delim)) { if (previousTokenWasDelim) components.Add(null); previousTokenWasDelim = true; } else { components.Add(thisTok); previousTokenWasDelim = false; } } System.String[] ret = new System.String[components.Count]; for (int i = 0; i < components.Count; i++) { ret[i] = ((System.String) components[i]); } return ret; }
/// <summary> Creates a ForwardWT object with the specified filters, and with other /// options specified in the parameter list 'pl'. /// /// </summary> /// <param name="src">The source of data to be transformed /// /// </param> /// <param name="pl">The parameter list (or options). /// /// </param> /// <param name="kers">The encoder specifications. /// /// </param> /// <returns> A new ForwardWT object with the specified filters and options /// from 'pl'. /// /// </returns> /// <exception cref="IllegalArgumentException">If mandatory parameters are missing /// or if invalid values are given. /// /// </exception> public static ForwardWT createInstance(BlkImgDataSrc src, ParameterList pl, EncoderSpecs encSpec) { int deflev; // defdec removed //System.String decompstr; //System.String wtstr; //System.String pstr; //SupportClass.StreamTokenizerSupport stok; //SupportClass.Tokenizer strtok; //int prefx, prefy; // Partitioning reference point coordinates // Check parameters pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo)); deflev = ((System.Int32)encSpec.dls.getDefault()); // Code-block partition origin System.String str = ""; if (pl.getParameter("Wcboff") == null) { throw new System.InvalidOperationException("You must specify an argument to the '-Wcboff' " + "option. See usage with the '-u' option"); } SupportClass.Tokenizer stk = new SupportClass.Tokenizer(pl.getParameter("Wcboff")); if (stk.Count != 2) { throw new System.ArgumentException("'-Wcboff' option needs two" + " arguments. See usage with " + "the '-u' option."); } int cb0x = 0; str = stk.NextToken(); try { cb0x = (System.Int32.Parse(str)); } catch (System.FormatException e) { throw new System.ArgumentException("Bad first parameter for the " + "'-Wcboff' option: " + str); } if (cb0x < 0 || cb0x > 1) { throw new System.ArgumentException("Invalid horizontal " + "code-block partition origin."); } int cb0y = 0; str = stk.NextToken(); try { cb0y = (System.Int32.Parse(str)); } catch (System.FormatException e) { throw new System.ArgumentException("Bad second parameter for the " + "'-Wcboff' option: " + str); } if (cb0y < 0 || cb0y > 1) { throw new System.ArgumentException("Invalid vertical " + "code-block partition origin."); } if (cb0x != 0 || cb0y != 0) { FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Code-blocks partition origin is " + "different from (0,0). This is defined in JPEG 2000" + " part 2 and may be not supported by all JPEG 2000 " + "decoders."); } return(new ForwWTFull(src, encSpec, cb0x, cb0y)); }
private IChemModel readChemModel(IChemModel model) { int[] atoms = new int[1]; double[] atomxs = new double[1]; double[] atomys = new double[1]; double[] atomzs = new double[1]; double[] atomcharges = new double[1]; int[] bondatomid1 = new int[1]; int[] bondatomid2 = new int[1]; int[] bondorder = new int[1]; int numberOfAtoms = 0; int numberOfBonds = 0; try { System.String line = input.ReadLine(); while (line != null) { SupportClass.Tokenizer st = new SupportClass.Tokenizer(line); System.String command = st.NextToken(); if ("!Header".Equals(command)) { //logger.warn("Ignoring header"); } else if ("!Info".Equals(command)) { //logger.warn("Ignoring info"); } else if ("!Atoms".Equals(command)) { //logger.info("Reading atom block"); // determine number of atoms to read try { numberOfAtoms = System.Int32.Parse(st.NextToken()); //logger.debug(" #atoms: " + numberOfAtoms); atoms = new int[numberOfAtoms]; atomxs = new double[numberOfAtoms]; atomys = new double[numberOfAtoms]; atomzs = new double[numberOfAtoms]; atomcharges = new double[numberOfAtoms]; for (int i = 0; i < numberOfAtoms; i++) { line = input.ReadLine(); SupportClass.Tokenizer atomInfoFields = new SupportClass.Tokenizer(line); int atomID = System.Int32.Parse(atomInfoFields.NextToken()); atoms[atomID] = System.Int32.Parse(atomInfoFields.NextToken()); //logger.debug("Set atomic number of atom (" + atomID + ") to: " + atoms[atomID]); } } catch (System.Exception exception) { //logger.error("Error while reading Atoms block"); //logger.debug(exception); } } else if ("!Bonds".Equals(command)) { //logger.info("Reading bond block"); try { // determine number of bonds to read numberOfBonds = System.Int32.Parse(st.NextToken()); bondatomid1 = new int[numberOfAtoms]; bondatomid2 = new int[numberOfAtoms]; bondorder = new int[numberOfAtoms]; for (int i = 0; i < numberOfBonds; i++) { line = input.ReadLine(); SupportClass.Tokenizer bondInfoFields = new SupportClass.Tokenizer(line); bondatomid1[i] = System.Int32.Parse(bondInfoFields.NextToken()); bondatomid2[i] = System.Int32.Parse(bondInfoFields.NextToken()); System.String order = bondInfoFields.NextToken(); if ("D".Equals(order)) { bondorder[i] = 2; } else if ("S".Equals(order)) { bondorder[i] = 1; } else if ("T".Equals(order)) { bondorder[i] = 3; } else { // ignore order, i.e. set to single //logger.warn("Unrecognized bond order, using single bond instead. Found: " + order); bondorder[i] = 1; } } } catch (System.Exception exception) { //logger.error("Error while reading Bonds block"); //logger.debug(exception); } } else if ("!Coord".Equals(command)) { //logger.info("Reading coordinate block"); try { for (int i = 0; i < numberOfAtoms; i++) { line = input.ReadLine(); SupportClass.Tokenizer atomInfoFields = new SupportClass.Tokenizer(line); int atomID = System.Int32.Parse(atomInfoFields.NextToken()); double x = System.Double.Parse(atomInfoFields.NextToken()); double y = System.Double.Parse(atomInfoFields.NextToken()); double z = System.Double.Parse(atomInfoFields.NextToken()); atomxs[atomID] = x; atomys[atomID] = y; atomzs[atomID] = z; } } catch (System.Exception exception) { //logger.error("Error while reading Coord block"); //logger.debug(exception); } } else if ("!Charges".Equals(command)) { //logger.info("Reading charges block"); try { for (int i = 0; i < numberOfAtoms; i++) { line = input.ReadLine(); SupportClass.Tokenizer atomInfoFields = new SupportClass.Tokenizer(line); int atomID = System.Int32.Parse(atomInfoFields.NextToken()); double charge = System.Double.Parse(atomInfoFields.NextToken()); atomcharges[atomID] = charge; } } catch (System.Exception exception) { //logger.error("Error while reading Charges block"); //logger.debug(exception); } } else if ("!End".Equals(command)) { //logger.info("Found end of file"); // Store atoms IAtomContainer container = model.Builder.newAtomContainer(); for (int i = 0; i < numberOfAtoms; i++) { try { IAtom atom = model.Builder.newAtom(IsotopeFactory.getInstance(container.Builder).getElementSymbol(atoms[i])); atom.AtomicNumber = atoms[i]; atom.setPoint3d(new Point3d(atomxs[i], atomys[i], atomzs[i])); atom.setCharge(atomcharges[i]); container.addAtom(atom); //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" //logger.debug("Stored atom: " + atom); } catch (System.Exception exception) { //logger.error("Cannot create an atom with atomic number: " + atoms[i]); //logger.debug(exception); } } // Store bonds for (int i = 0; i < numberOfBonds; i++) { container.addBond(bondatomid1[i], bondatomid2[i], bondorder[i]); } ISetOfMolecules moleculeSet = model.Builder.newSetOfMolecules(); moleculeSet.addMolecule(model.Builder.newMolecule(container)); model.SetOfMolecules = moleculeSet; return(model); } else { //logger.warn("Skipping line: " + line); } line = input.ReadLine(); } } catch (System.Exception exception) { //logger.error("Error while reading file"); //logger.debug(exception); } // this should not happen, file is lacking !End command return(null); }
/// <summary> Constructs a new 'AnWTFilterSpec' for the specified number of /// components and tiles. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">the type of the specification module i.e. tile specific, /// component specific or both. /// /// </param> /// <param name="qts">Quantization specifications /// /// </param> /// <param name="pl">The ParameterList /// /// </param> public AnWTFilterSpec(int nt, int nc, byte type, QuantTypeSpec qts, ParameterList pl) : base(nt, nc, type) { // Check parameters pl.checkList(AnWTFilter.OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(AnWTFilter.ParameterInfo)); System.String param = pl.getParameter("Ffilters"); bool isFilterSpecified = true; // No parameter specified if (param == null) { isFilterSpecified = false; // If lossless compression, uses the reversible filters in each // tile-components if (pl.getBooleanParameter("lossless")) { setDefault(parseFilters(REV_FILTER_STR)); return; } // If no filter is specified through the command-line, use // REV_FILTER_STR or NON_REV_FILTER_STR according to the // quantization type for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { switch (qts.getSpecValType(t, c)) { case SPEC_DEF: if (getDefault() == null) { if (pl.getBooleanParameter("lossless")) { setDefault(parseFilters(REV_FILTER_STR)); } if (((System.String)qts.getDefault()).Equals("reversible")) { setDefault(parseFilters(REV_FILTER_STR)); } else { setDefault(parseFilters(NON_REV_FILTER_STR)); } } specValType[t][c] = SPEC_DEF; break; case SPEC_COMP_DEF: if (!isCompSpecified(c)) { if (((System.String)qts.getCompDef(c)).Equals("reversible")) { setCompDef(c, parseFilters(REV_FILTER_STR)); } else { setCompDef(c, parseFilters(NON_REV_FILTER_STR)); } } specValType[t][c] = SPEC_COMP_DEF; break; case SPEC_TILE_DEF: if (!isTileSpecified(t)) { if (((System.String)qts.getTileDef(t)).Equals("reversible")) { setTileDef(t, parseFilters(REV_FILTER_STR)); } else { setTileDef(t, parseFilters(NON_REV_FILTER_STR)); } } specValType[t][c] = SPEC_TILE_DEF; break; case SPEC_TILE_COMP: if (!isTileCompSpecified(t, c)) { if (((System.String)qts.getTileCompVal(t, c)).Equals("reversible")) { setTileCompVal(t, c, parseFilters(REV_FILTER_STR)); } else { setTileCompVal(t, c, parseFilters(NON_REV_FILTER_STR)); } } specValType[t][c] = SPEC_TILE_COMP; break; default: throw new System.ArgumentException("Unsupported " + "specification " + "type"); } } } return; } // Parse argument SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); System.String word; // current word byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification AnWTFilter[][] filter; while (stk.HasMoreTokens()) { word = stk.NextToken(); switch (word[0]) { case 't': // Tiles specification case 'T': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_TILE_DEF; } break; case 'c': // Components specification case 'C': // Components specification compSpec = parseIdx(word, nComp); if (curSpecType == SPEC_TILE_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_COMP_DEF; } break; case 'w': // WT filters specification case 'W': // WT filters specification if (pl.getBooleanParameter("lossless") && word.ToUpper().Equals("w9x7".ToUpper())) { throw new System.ArgumentException("Cannot use non " + "reversible " + "wavelet transform with" + " '-lossless' option"); } filter = parseFilters(word); if (curSpecType == SPEC_DEF) { setDefault(filter); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) { if (tileSpec[i]) { setTileDef(i, filter); } } } else if (curSpecType == SPEC_COMP_DEF) { for (int i = compSpec.Length - 1; i >= 0; i--) { if (compSpec[i]) { setCompDef(i, filter); } } } else { for (int i = tileSpec.Length - 1; i >= 0; i--) { for (int j = compSpec.Length - 1; j >= 0; j--) { if (tileSpec[i] && compSpec[j]) { setTileCompVal(i, j, filter); } } } } // Re-initialize curSpecType = SPEC_DEF; tileSpec = null; compSpec = null; break; default: throw new System.ArgumentException("Bad construction for " + "parameter: " + word); } } // Check that default value has been specified if (getDefault() == null) { int ndefspec = 0; for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { if (specValType[t][c] == SPEC_DEF) { ndefspec++; } } } // If some tile-component have received no specification, it takes // the default value defined in ParameterList if (ndefspec != 0) { if (((System.String)qts.getDefault()).Equals("reversible")) { setDefault(parseFilters(REV_FILTER_STR)); } else { setDefault(parseFilters(NON_REV_FILTER_STR)); } } else { // All tile-component have been specified, takes the first // tile-component value as default. setDefault(getTileCompVal(0, 0)); switch (specValType[0][0]) { case SPEC_TILE_DEF: for (int c = nc - 1; c >= 0; c--) { if (specValType[0][c] == SPEC_TILE_DEF) { specValType[0][c] = SPEC_DEF; } } tileDef[0] = null; break; case SPEC_COMP_DEF: for (int t = nt - 1; t >= 0; t--) { if (specValType[t][0] == SPEC_COMP_DEF) { specValType[t][0] = SPEC_DEF; } } compDef[0] = null; break; case SPEC_TILE_COMP: specValType[0][0] = SPEC_DEF; tileCompVal["t0c0"] = null; break; } } } // Check consistency between filter and quantization type // specification for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { // Reversible quantization if (((System.String)qts.getTileCompVal(t, c)).Equals("reversible")) { // If filter is reversible, it is OK if (isReversible(t, c)) { continue; } // If no filter has been defined, use reversible filter if (!isFilterSpecified) { setTileCompVal(t, c, parseFilters(REV_FILTER_STR)); } else { // Non reversible filter specified -> Error throw new System.ArgumentException("Filter of " + "tile-component" + " (" + t + "," + c + ") does" + " not allow " + "reversible " + "quantization. " + "Specify '-Qtype " + "expounded' or " + "'-Qtype derived'" + "in " + "the command line."); } } else { // No reversible quantization // No reversible filter -> OK if (!isReversible(t, c)) { continue; } // If no filter has been specified, use non-reversible // filter if (!isFilterSpecified) { setTileCompVal(t, c, parseFilters(NON_REV_FILTER_STR)); } else { // Reversible filter specified -> Error throw new System.ArgumentException("Filter of " + "tile-component" + " (" + t + "," + c + ") does" + " not allow " + "non-reversible " + "quantization. " + "Specify '-Qtype " + "reversible' in " + "the command line"); } } } } }
/// <summary> Creates a new PrecinctSizeSpec object for the specified number of tiles /// and components and the ParameterList instance. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">the type of the specification module i.e. tile specific, /// component specific or both. /// /// </param> /// <param name="imgsrc">The image source (used to get the image size) /// /// </param> /// <param name="pl">The ParameterList instance /// /// </param> public PrecinctSizeSpec(int nt, int nc, byte type, BlkImgDataSrc imgsrc, IntegerSpec dls, ParameterList pl) : base(nt, nc, type) { this.dls = dls; // The precinct sizes are stored in a 2 elements vector array, the // first element containing a vector for the precincts width for each // resolution level and the second element containing a vector for the // precincts height for each resolution level. The precincts sizes are // specified from the highest resolution level to the lowest one // (i.e. 0). If there are less elements than the number of // decomposition levels, the last element is used for all remaining // resolution levels (i.e. if the precincts sizes are specified only // for resolutions levels 5, 4 and 3, then the precincts size for // resolution levels 2, 1 and 0 will be the same as the size used for // resolution level 3). // Boolean used to know if we were previously reading a precinct's // size or if we were reading something else. bool wasReadingPrecinctSize = false; System.String param = pl.getParameter(optName); // Set precinct sizes to default i.e. 2^15 = // Markers.PRECINCT_PARTITION_DEF_SIZE System.Collections.ArrayList[] tmpv = new System.Collections.ArrayList[2]; tmpv[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppx tmpv[0].Add((System.Int32)CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE); tmpv[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppy tmpv[1].Add((System.Int32)CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE); setDefault(tmpv); if (param == null) { // No precinct size specified in the command line so we do not try // to parse it. return; } // Precinct partition is used : parse arguments SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification int ci, ti; //i, xIdx removed bool endOfParamList = false; System.String word = null; // current word System.Int32 w, h; System.String errMsg = null; while ((stk.HasMoreTokens() || wasReadingPrecinctSize) && !endOfParamList) { System.Collections.ArrayList[] v = new System.Collections.ArrayList[2]; // v[0] : ppx, v[1] : ppy // We do not read the next token if we were reading a precinct's // size argument as we have already read the next token into word. if (!wasReadingPrecinctSize) { word = stk.NextToken(); } wasReadingPrecinctSize = false; switch (word[0]) { case 't': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_TILE_DEF; } break; case 'c': // Components specification compSpec = parseIdx(word, nComp); if (curSpecType == SPEC_TILE_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_COMP_DEF; } break; default: if (!System.Char.IsDigit(word[0])) { errMsg = "Bad construction for parameter: " + word; throw new System.ArgumentException(errMsg); } // Initialises Vector objects v[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppx v[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppy while (true) { // Now get the precinct dimensions try { // Get precinct width w = System.Int32.Parse(word); // Get next word in argument list try { word = stk.NextToken(); } catch (System.ArgumentOutOfRangeException) { errMsg = "'" + optName + "' option : could not " + "parse the precinct's width"; throw new System.ArgumentException(errMsg); } // Get precinct height h = System.Int32.Parse(word); if (w != (1 << MathUtil.log2(w)) || h != (1 << MathUtil.log2(h))) { errMsg = "Precinct dimensions must be powers of 2"; throw new System.ArgumentException(errMsg); } } catch (System.FormatException) { errMsg = "'" + optName + "' option : the argument '" + word + "' could not be parsed."; throw new System.ArgumentException(errMsg); } // Store packet's dimensions in Vector arrays v[0].Add(w); v[1].Add(h); // Try to get the next token if (stk.HasMoreTokens()) { word = stk.NextToken(); if (!System.Char.IsDigit(word[0])) { // The next token does not start with a digit so // it is not a precinct's size argument. We set // the wasReadingPrecinctSize booleen such that we // know that we don't have to read another token // and check for the end of the parameters list. wasReadingPrecinctSize = true; if (curSpecType == SPEC_DEF) { setDefault(v); } else if (curSpecType == SPEC_TILE_DEF) { for (ti = tileSpec.Length - 1; ti >= 0; ti--) { if (tileSpec[ti]) { setTileDef(ti, v); } } } else if (curSpecType == SPEC_COMP_DEF) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (compSpec[ci]) { setCompDef(ci, v); } } } else { for (ti = tileSpec.Length - 1; ti >= 0; ti--) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (tileSpec[ti] && compSpec[ci]) { setTileCompVal(ti, ci, v); } } } } // Re-initialize curSpecType = SPEC_DEF; tileSpec = null; compSpec = null; // Go back to 'normal' parsing break; } else { // Next token starts with a digit so read it } } else { // We have reached the end of the parameters list so // we store the last precinct's sizes and we stop if (curSpecType == SPEC_DEF) { setDefault(v); } else if (curSpecType == SPEC_TILE_DEF) { for (ti = tileSpec.Length - 1; ti >= 0; ti--) { if (tileSpec[ti]) { setTileDef(ti, v); } } } else if (curSpecType == SPEC_COMP_DEF) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (compSpec[ci]) { setCompDef(ci, v); } } } else { for (ti = tileSpec.Length - 1; ti >= 0; ti--) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (tileSpec[ti] && compSpec[ci]) { setTileCompVal(ti, ci, v); } } } } endOfParamList = true; break; } } // while (true) break; } // switch } // while }
/// <summary> Constructs a new 'AnWTFilterSpec' for the specified number of /// components and tiles. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">the type of the specification module i.e. tile specific, /// component specific or both. /// /// </param> /// <param name="qts">Quantization specifications /// /// </param> /// <param name="pl">The ParameterList /// /// </param> public AnWTFilterSpec(int nt, int nc, byte type, QuantTypeSpec qts, ParameterList pl):base(nt, nc, type) { // Check parameters pl.checkList(AnWTFilter.OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(AnWTFilter.ParameterInfo)); System.String param = pl.getParameter("Ffilters"); bool isFilterSpecified = true; // No parameter specified if (param == null) { isFilterSpecified = false; // If lossless compression, uses the reversible filters in each // tile-components if (pl.getBooleanParameter("lossless")) { setDefault(parseFilters(REV_FILTER_STR)); return ; } // If no filter is specified through the command-line, use // REV_FILTER_STR or NON_REV_FILTER_STR according to the // quantization type for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { switch (qts.getSpecValType(t, c)) { case SPEC_DEF: if (getDefault() == null) { if (pl.getBooleanParameter("lossless")) setDefault(parseFilters(REV_FILTER_STR)); if (((System.String) qts.getDefault()).Equals("reversible")) { setDefault(parseFilters(REV_FILTER_STR)); } else { setDefault(parseFilters(NON_REV_FILTER_STR)); } } specValType[t][c] = SPEC_DEF; break; case SPEC_COMP_DEF: if (!isCompSpecified(c)) { if (((System.String) qts.getCompDef(c)).Equals("reversible")) { setCompDef(c, parseFilters(REV_FILTER_STR)); } else { setCompDef(c, parseFilters(NON_REV_FILTER_STR)); } } specValType[t][c] = SPEC_COMP_DEF; break; case SPEC_TILE_DEF: if (!isTileSpecified(t)) { if (((System.String) qts.getTileDef(t)).Equals("reversible")) { setTileDef(t, parseFilters(REV_FILTER_STR)); } else { setTileDef(t, parseFilters(NON_REV_FILTER_STR)); } } specValType[t][c] = SPEC_TILE_DEF; break; case SPEC_TILE_COMP: if (!isTileCompSpecified(t, c)) { if (((System.String) qts.getTileCompVal(t, c)).Equals("reversible")) { setTileCompVal(t, c, parseFilters(REV_FILTER_STR)); } else { setTileCompVal(t, c, parseFilters(NON_REV_FILTER_STR)); } } specValType[t][c] = SPEC_TILE_COMP; break; default: throw new System.ArgumentException("Unsupported " + "specification " + "type"); } } } return ; } // Parse argument SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); System.String word; // current word byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification AnWTFilter[][] filter; while (stk.HasMoreTokens()) { word = stk.NextToken(); switch (word[0]) { case 't': // Tiles specification case 'T': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) curSpecType = SPEC_TILE_COMP; else curSpecType = SPEC_TILE_DEF; break; case 'c': // Components specification case 'C': // Components specification compSpec = parseIdx(word, nComp); if (curSpecType == SPEC_TILE_DEF) curSpecType = SPEC_TILE_COMP; else curSpecType = SPEC_COMP_DEF; break; case 'w': // WT filters specification case 'W': // WT filters specification if (pl.getBooleanParameter("lossless") && word.ToUpper().Equals("w9x7".ToUpper())) { throw new System.ArgumentException("Cannot use non " + "reversible " + "wavelet transform with" + " '-lossless' option"); } filter = parseFilters(word); if (curSpecType == SPEC_DEF) { setDefault(filter); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) if (tileSpec[i]) { setTileDef(i, filter); } } else if (curSpecType == SPEC_COMP_DEF) { for (int i = compSpec.Length - 1; i >= 0; i--) if (compSpec[i]) { setCompDef(i, filter); } } else { for (int i = tileSpec.Length - 1; i >= 0; i--) { for (int j = compSpec.Length - 1; j >= 0; j--) { if (tileSpec[i] && compSpec[j]) { setTileCompVal(i, j, filter); } } } } // Re-initialize curSpecType = SPEC_DEF; tileSpec = null; compSpec = null; break; default: throw new System.ArgumentException("Bad construction for " + "parameter: " + word); } } // Check that default value has been specified if (getDefault() == null) { int ndefspec = 0; for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { if (specValType[t][c] == SPEC_DEF) { ndefspec++; } } } // If some tile-component have received no specification, it takes // the default value defined in ParameterList if (ndefspec != 0) { if (((System.String) qts.getDefault()).Equals("reversible")) setDefault(parseFilters(REV_FILTER_STR)); else setDefault(parseFilters(NON_REV_FILTER_STR)); } else { // All tile-component have been specified, takes the first // tile-component value as default. setDefault(getTileCompVal(0, 0)); switch (specValType[0][0]) { case SPEC_TILE_DEF: for (int c = nc - 1; c >= 0; c--) { if (specValType[0][c] == SPEC_TILE_DEF) specValType[0][c] = SPEC_DEF; } tileDef[0] = null; break; case SPEC_COMP_DEF: for (int t = nt - 1; t >= 0; t--) { if (specValType[t][0] == SPEC_COMP_DEF) specValType[t][0] = SPEC_DEF; } compDef[0] = null; break; case SPEC_TILE_COMP: specValType[0][0] = SPEC_DEF; tileCompVal["t0c0"] = null; break; } } } // Check consistency between filter and quantization type // specification for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { // Reversible quantization if (((System.String) qts.getTileCompVal(t, c)).Equals("reversible")) { // If filter is reversible, it is OK if (isReversible(t, c)) continue; // If no filter has been defined, use reversible filter if (!isFilterSpecified) { setTileCompVal(t, c, parseFilters(REV_FILTER_STR)); } else { // Non reversible filter specified -> Error throw new System.ArgumentException("Filter of " + "tile-component" + " (" + t + "," + c + ") does" + " not allow " + "reversible " + "quantization. " + "Specify '-Qtype " + "expounded' or " + "'-Qtype derived'" + "in " + "the command line."); } } else { // No reversible quantization // No reversible filter -> OK if (!isReversible(t, c)) continue; // If no filter has been specified, use non-reversible // filter if (!isFilterSpecified) { setTileCompVal(t, c, parseFilters(NON_REV_FILTER_STR)); } else { // Reversible filter specified -> Error throw new System.ArgumentException("Filter of " + "tile-component" + " (" + t + "," + c + ") does" + " not allow " + "non-reversible " + "quantization. " + "Specify '-Qtype " + "reversible' in " + "the command line"); } } } } }
/// <summary> Locates the member via a dotted name starting at the given id. /// It will traverse any and all proto chains if necc. to find the name. /// </summary> internal virtual Value locate(int startingId, String dottedName, bool traverseProto) { if (dottedName == null) return null; // first rip apart the dottedName SupportClass.Tokenizer names = new SupportClass.Tokenizer(dottedName, "."); //$NON-NLS-1$ Value val = Session.getValue(startingId); while (names.HasMoreTokens() && val != null) { val = locateForNamed(val.Id, names.NextToken(), traverseProto).getValue(); } return val; }
//************************************************************************* // connect methods //************************************************************************* /// <summary> /// Connects to the specified host and port. /// /// If this LdapConnection object represents an open connection, the /// connection is closed first before the new connection is opened. /// At this point, there is no authentication, and any operations are /// conducted as an anonymous client. /// /// When more than one host name is specified, each host is contacted /// in turn until a connection can be established. /// /// </summary> /// <param name="host">A host name or a dotted string representing the IP address /// of a host running an Ldap server. It may also /// contain a list of host names, space-delimited. Each host /// name can include a trailing colon and port number. /// /// </param> /// <param name="port">The TCP or UDP port number to connect to or contact. /// The default Ldap port is 389. The port parameter is /// ignored for any host hame which includes a colon and /// port number. /// /// </param> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// /// </exception> public virtual void Connect(System.String host, int port) { // connect doesn't affect other clones // If not a clone, destroys old connection. // Step through the space-delimited list SupportClass.Tokenizer hostList = new SupportClass.Tokenizer(host, " "); System.String address = null; int specifiedPort; int colonIndex; //after the colon is the port while (hostList.HasMoreTokens()) { try { specifiedPort = port; address = hostList.NextToken(); colonIndex = address.IndexOf((System.Char) ':'); if (colonIndex != - 1 && colonIndex + 1 != address.Length) { //parse Port out of address try { specifiedPort = System.Int32.Parse(address.Substring(colonIndex + 1)); address = address.Substring(0, (colonIndex) - (0)); } catch (System.Exception e) { throw new System.ArgumentException(ExceptionMessages.INVALID_ADDRESS); } } // This may return a different conn object // Disassociate this clone with the underlying connection. conn = conn.destroyClone(true); conn.connect(address, specifiedPort); break; } catch (LdapException LE) { if (!hostList.HasMoreTokens()) throw LE; } } return ; }
private static ArrayList[] predict(System.IO.StreamReader input, System.IO.StreamWriter output, svm_model model, int predict_probability) { //int correct = 0; //int total = 0; //double error = 0; //double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0; ArrayList[] arrResult = new ArrayList[2];//Mảng thứ 1 chứa kết quả thực sự, mảng thứ 2 chứa kết quả dự đoán arrResult[0] = new ArrayList(); arrResult[1] = new ArrayList(); int svm_type = svm.svm_get_svm_type(model); int nr_class = svm.svm_get_nr_class(model); int[] labels = new int[nr_class]; double[] prob_estimates = null; if (predict_probability == 1) { if (svm_type == svm_parameter.EPSILON_SVR || svm_type == svm_parameter.NU_SVR) { System.Console.Out.Write("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=" + svm.svm_get_svr_probability(model) + "\n"); } else { svm.svm_get_labels(model, labels); prob_estimates = new double[nr_class]; //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("labels"); for (int j = 0; j < nr_class; j++) { //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(" " + labels[j]); } //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("\n"); } } #region [Thêm] Lấy thông tin tiền xử lý từ dòng đầu của file test System.String strPreprocess = input.ReadLine(); #endregion while (true) { System.String line = input.ReadLine(); if ((System.Object)line == null) break; SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " \t\n\r\f:"); double target = atof(st.NextToken()); int m = st.Count / 2; svm_node[] x = new svm_node[m]; for (int j = 0; j < m; j++) { x[j] = new svm_node(); x[j].index = atoi(st.NextToken()); x[j].value_Renamed = atof(st.NextToken()); } double v; if (predict_probability == 1 && (svm_type == svm_parameter.C_SVC || svm_type == svm_parameter.NU_SVC)) { v = svm.svm_predict_probability(model, x, prob_estimates); //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(v + " "); for (int j = 0; j < nr_class; j++) { //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(prob_estimates[j] + " "); } //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("\n"); } else { v = svm.svm_predict(model, x); #region [Thêm] Chuyển về dữ liệu nguyên thủy dựa vào cách tiền xử lý string[] strItems = strPreprocess.Split(' '); double dblMin; double dblMax; double dblDiff; switch (strItems[0]) { case "ScaleByMinMax": dblMin = Convert.ToDouble(strItems[1]); dblMax = Convert.ToDouble(strItems[2]); dblDiff = dblMax - dblMin; v = v * dblDiff + dblMin; target = target * dblDiff + dblMin; break; default: break; } #endregion arrResult[0].Add(target); arrResult[1].Add(v); //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(target + " " + v + "\n"); } //#region [Thêm] Chuyển về dữ liệu nguyên thủy dựa vào cách tiền xử lý //string[] strItems = strPreprocess.Split(' '); //switch (strItems[0]) //{ // case "Scale(0,1)": // double dblMin = Convert.ToDouble(strItems[1]); // double dblMax = Convert.ToDouble(strItems[2]); // double dblDiff = dblMax - dblMin; // v = (v - 0.15) * dblDiff / 0.7 + dblMin; // target = (target - 0.15) * dblDiff / 0.7 + dblMin; // break; // default: // break; //} //#endregion //arrResult[0].Add(target); //arrResult[1].Add(v); //if (v == target) // ++correct; //error += (v - target) * (v - target); //sumv += v; //sumy += target; //sumvv += v * v; //sumyy += target * target; //sumvy += v * target; //++total; } return arrResult; //System.Console.Out.Write("Accuracy = " + (double) correct / total * 100 + "% (" + correct + "/" + total + ") (classification)\n"); //System.Console.Out.Write("Mean squared error = " + error / total + " (regression)\n"); //System.Console.Out.Write("Squared correlation coefficient = " + ((total * sumvy - sumv * sumy) * (total * sumvy - sumv * sumy)) / ((total * sumvv - sumv * sumv) * (total * sumyy - sumy * sumy)) + " (regression)\n"); }
/// <summary> Extracts the subtypes from the specified attribute name. /// /// For example, if the attribute name is cn;lang-ja;phonetic, /// this method returns an array containing lang-ja and phonetic. /// /// </summary> /// <param name="attrName"> Name of the attribute from which to extract /// the subtypes. /// /// </param> /// <returns> An array subtypes or null if the attribute has none. /// /// @throws IllegalArgumentException if attrName is null /// </returns> public static System.String[] getSubtypes(System.String attrName) { if ((System.Object) attrName == null) { throw new System.ArgumentException("Attribute name cannot be null"); } SupportClass.Tokenizer st = new SupportClass.Tokenizer(attrName, ";"); System.String[] subTypes = null; int cnt = st.Count; if (cnt > 0) { st.NextToken(); // skip over basename subTypes = new System.String[cnt - 1]; int i = 0; while (st.HasMoreTokens()) { subTypes[i++] = st.NextToken(); } } return subTypes; }
/// <summary> Constructs a new 'IntegerSpec' for the specified number of tiles and /// components, the allowed specifications type and the ParameterList /// instance. This constructor is normally called at encoder side and parse /// arguments of specified option. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">The allowed specifications type /// /// </param> /// <param name="pl">The ParameterList instance /// /// </param> /// <param name="optName">The name of the option to process /// /// </param> public IntegerSpec(int nt, int nc, byte type, ParameterList pl, System.String optName) : base(nt, nc, type) { System.Int32 value_Renamed; System.String param = pl.getParameter(optName); if (param == null) { // No parameter specified param = pl.DefaultParameterList.getParameter(optName); try { setDefault((System.Object)System.Int32.Parse(param)); } catch (System.FormatException e) { throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + param); } return; } // Parse argument SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); System.String word; // current word byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification while (stk.HasMoreTokens()) { word = stk.NextToken(); switch (word[0]) { case 't': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_TILE_DEF; } break; case 'c': // Components specification compSpec = parseIdx(word, nComp); if (curSpecType == SPEC_TILE_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_COMP_DEF; } break; default: try { value_Renamed = System.Int32.Parse(word); } catch (System.FormatException e) { throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + word); } if (curSpecType == SPEC_DEF) { setDefault((System.Object)value_Renamed); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) { if (tileSpec[i]) { setTileDef(i, (System.Object)value_Renamed); } } } else if (curSpecType == SPEC_COMP_DEF) { for (int i = compSpec.Length - 1; i >= 0; i--) { if (compSpec[i]) { setCompDef(i, (System.Object)value_Renamed); } } } else { for (int i = tileSpec.Length - 1; i >= 0; i--) { for (int j = compSpec.Length - 1; j >= 0; j--) { if (tileSpec[i] && compSpec[j]) { setTileCompVal(i, j, (System.Object)value_Renamed); } } } } // Re-initialize curSpecType = SPEC_DEF; tileSpec = null; compSpec = null; break; } } // Check that default value has been specified if (getDefault() == null) { int ndefspec = 0; for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { if (specValType[t][c] == SPEC_DEF) { ndefspec++; } } } // If some tile-component have received no specification, it takes // the default value defined in ParameterList if (ndefspec != 0) { param = pl.DefaultParameterList.getParameter(optName); try { setDefault((System.Object)System.Int32.Parse(param)); } catch (System.FormatException e) { throw new System.ArgumentException("Non recognized value" + " for option -" + optName + ": " + param); } } else { // All tile-component have been specified, takes the first // tile-component value as default. setDefault(getTileCompVal(0, 0)); switch (specValType[0][0]) { case SPEC_TILE_DEF: for (int c = nc - 1; c >= 0; c--) { if (specValType[0][c] == SPEC_TILE_DEF) { specValType[0][c] = SPEC_DEF; } } tileDef[0] = null; break; case SPEC_COMP_DEF: for (int t = nt - 1; t >= 0; t--) { if (specValType[t][0] == SPEC_COMP_DEF) { specValType[t][0] = SPEC_DEF; } } compDef[0] = null; break; case SPEC_TILE_COMP: specValType[0][0] = SPEC_DEF; tileCompVal["t0c0"] = null; break; } } } }
/// <summary> Constructs a new 'GuardBitsSpec' for the specified number of components /// and tiles and the arguments of "-Qguard_bits" option. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">the type of the specification module i.e. tile specific, /// component specific or both. /// /// </param> /// <param name="pl">The ParameterList /// /// </param> public GuardBitsSpec(int nt, int nc, byte type, ParameterList pl):base(nt, nc, type) { System.String param = pl.getParameter("Qguard_bits"); if (param == null) { throw new System.ArgumentException("Qguard_bits option not " + "specified"); } // Parse argument SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); System.String word; // current word byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification System.Int32 value_Renamed; // value of the guard bits while (stk.HasMoreTokens()) { word = stk.NextToken().ToLower(); switch (word[0]) { case 't': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) curSpecType = SPEC_TILE_COMP; else curSpecType = SPEC_TILE_DEF; break; case 'c': // Components specification compSpec = parseIdx(word, nComp); if (curSpecType == SPEC_TILE_DEF) curSpecType = SPEC_TILE_COMP; else curSpecType = SPEC_COMP_DEF; break; default: // Step size value try { value_Renamed = System.Int32.Parse(word); } catch (System.FormatException) { throw new System.ArgumentException("Bad parameter for " + "-Qguard_bits option" + " : " + word); } if ((float) value_Renamed <= 0.0f) { throw new System.ArgumentException("Guard bits value " + "must be positive : " + value_Renamed); } if (curSpecType == SPEC_DEF) { setDefault((System.Object) value_Renamed); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) if (tileSpec[i]) { setTileDef(i, (System.Object) value_Renamed); } } else if (curSpecType == SPEC_COMP_DEF) { for (int i = compSpec.Length - 1; i >= 0; i--) if (compSpec[i]) { setCompDef(i, (System.Object) value_Renamed); } } else { for (int i = tileSpec.Length - 1; i >= 0; i--) { for (int j = compSpec.Length - 1; j >= 0; j--) { if (tileSpec[i] && compSpec[j]) { setTileCompVal(i, j, (System.Object) value_Renamed); } } } } // Re-initialize curSpecType = SPEC_DEF; tileSpec = null; compSpec = null; break; } } // Check that default value has been specified if (getDefault() == null) { int ndefspec = 0; for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { if (specValType[t][c] == SPEC_DEF) { ndefspec++; } } } // If some tile-component have received no specification, it takes // the default value defined in ParameterList if (ndefspec != 0) { setDefault((System.Object) System.Int32.Parse(pl.DefaultParameterList.getParameter("Qguard_bits"))); } else { // All tile-component have been specified, takes the first // tile-component value as default. setDefault(getTileCompVal(0, 0)); switch (specValType[0][0]) { case SPEC_TILE_DEF: for (int c = nc - 1; c >= 0; c--) { if (specValType[0][c] == SPEC_TILE_DEF) specValType[0][c] = SPEC_DEF; } tileDef[0] = null; break; case SPEC_COMP_DEF: for (int t = nt - 1; t >= 0; t--) { if (specValType[t][0] == SPEC_COMP_DEF) specValType[t][0] = SPEC_DEF; } compDef[0] = null; break; case SPEC_TILE_COMP: specValType[0][0] = SPEC_DEF; tileCompVal["t0c0"] = null; break; } } } }
/// <summary> Returns the query portion of the URL, broken up into individual key/value /// pairs. Does NOT unescape the keys and values. /// </summary> public virtual LinkedHashMap getParameterMap() { LinkedHashMap map; SupportClass.Tokenizer tokens = new SupportClass.Tokenizer(Query, "?&"); //$NON-NLS-1$ // multiply by 2 to create a sufficiently large HashMap map = new LinkedHashMap(tokens.Count * 2); while (tokens.HasMoreTokens()) { String nameValuePair = tokens.NextToken(); String name = nameValuePair; String value = ""; //$NON-NLS-1$ int equalsIndex = nameValuePair.IndexOf('='); if (equalsIndex != - 1) { name = nameValuePair.Substring(0, (equalsIndex) - (0)); if (name.Length > 0) { value = nameValuePair.Substring(equalsIndex + 1); } } map.Add(name, value); } return map; }
// read in a problem (in svmlight format) private void read_problem() { /* UPGRADE_TODO: Expected value of parameters of constructor * 'java.io.BufferedReader.BufferedReader' are different in the equivalent in .NET. * 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1092"' */ System.IO.StreamReader fp = new System.IO.StreamReader(input_file_name); System.Collections.ArrayList vy = new System.Collections.ArrayList(10); System.Collections.ArrayList vx = new System.Collections.ArrayList(10); int max_index = 0; while (true) { System.String line = fp.ReadLine(); if ((System.Object) line == null) break; SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " \t\n\r\f:"); vy.Add(st.NextToken()); int m = st.Count / 2; svm_node[] x = new svm_node[m]; for (int j = 0; j < m; j++) { x[j] = new svm_node(); x[j].index = atoi(st.NextToken()); x[j].value_Renamed = atof(st.NextToken()); } if (m > 0) max_index = System.Math.Max(max_index, x[m - 1].index); vx.Add(x); } prob = new svm_problem(); prob.l = vy.Count; prob.x = new svm_node[prob.l][]; for (int i = 0; i < prob.l; i++) prob.x[i] = (svm_node[]) vx[i]; prob.y = new double[prob.l]; for (int i = 0; i < prob.l; i++) prob.y[i] = atof((System.String) vy[i]); if (param.gamma == 0) param.gamma = 1.0 / max_index; fp.Close(); }
/// <summary> /// Hacky method to figure out the relative path /// that we are currently in. This is good for getting /// the relative path for images and anchor's. /// </summary> private String getRelativePath(String file) { if (file == null || file.Length == 0) return ""; SupportClass.Tokenizer st = new SupportClass.Tokenizer(file, "/\\"); // needs to be -1 cause ST returns 1 even if there are no matches. huh? int slashCount = st.Count - 1; System.Text.StringBuilder sb = new System.Text.StringBuilder(); for (int i = 0; i < slashCount; i++) { sb.Append("../"); } if (sb.ToString().Length > 0) { return StringUtils.chop(sb.ToString(), 1); } else { return "."; } }
public static svm_model svm_load_model(System.String model_file_name) { //UPGRADE_TODO: The differences in the expected value of parameters for constructor 'java.io.BufferedReader.BufferedReader' may cause compilation errors. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1092_3"' //UPGRADE_WARNING: At least one expression was used more than once in the target code. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1181_3"' //UPGRADE_TODO: Constructor 'java.io.FileReader.FileReader' was converted to 'System.IO.StreamReader' which has a different behavior. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1073_3"' /*Original System.IO.StreamReader fp = new System.IO.StreamReader(new System.IO.StreamReader(model_file_name, System.Text.Encoding.Default).BaseStream, new System.IO.StreamReader(model_file_name, System.Text.Encoding.Default).CurrentEncoding);*/ System.IO.StreamReader fp = new System.IO.StreamReader(new System.IO.FileStream(model_file_name, System.IO.FileMode.Open)); // read parameters svm_model model = new svm_model(); svm_parameter param = new svm_parameter(); model.param = param; model.rho = null; model.probA = null; model.probB = null; model.label = null; model.nSV = null; while (true) { System.String cmd = fp.ReadLine(); System.String arg = cmd.Substring(cmd.IndexOf((System.Char) ' ') + 1); if (cmd.StartsWith("svm_type")) { int i; for (i = 0; i < svm_type_table.Length; i++) { if (arg.IndexOf(svm_type_table[i]) != - 1) { param.svm_type = i; break; } } if (i == svm_type_table.Length) { System.Console.Error.Write("unknown svm type.\n"); return null; } } else if (cmd.StartsWith("kernel_type")) { int i; for (i = 0; i < kernel_type_table.Length; i++) { if (arg.IndexOf(kernel_type_table[i]) != - 1) { param.kernel_type = i; break; } } if (i == kernel_type_table.Length) { System.Console.Error.Write("unknown kernel function.\n"); return null; } } else if (cmd.StartsWith("degree")) param.degree = atof(arg); else if (cmd.StartsWith("gamma")) param.gamma = atof(arg); else if (cmd.StartsWith("coef0")) param.coef0 = atof(arg); else if (cmd.StartsWith("nr_class")) model.nr_class = atoi(arg); else if (cmd.StartsWith("total_sv")) model.l = atoi(arg); else if (cmd.StartsWith("rho")) { int n = model.nr_class * (model.nr_class - 1) / 2; model.rho = new double[n]; SupportClass.Tokenizer st = new SupportClass.Tokenizer(arg); for (int i = 0; i < n; i++) model.rho[i] = atof(st.NextToken()); } else if (cmd.StartsWith("label")) { int n = model.nr_class; model.label = new int[n]; SupportClass.Tokenizer st = new SupportClass.Tokenizer(arg); for (int i = 0; i < n; i++) model.label[i] = atoi(st.NextToken()); } else if (cmd.StartsWith("probA")) { int n = model.nr_class * (model.nr_class - 1) / 2; model.probA = new double[n]; SupportClass.Tokenizer st = new SupportClass.Tokenizer(arg); for (int i = 0; i < n; i++) model.probA[i] = atof(st.NextToken()); } else if (cmd.StartsWith("probB")) { int n = model.nr_class * (model.nr_class - 1) / 2; model.probB = new double[n]; SupportClass.Tokenizer st = new SupportClass.Tokenizer(arg); for (int i = 0; i < n; i++) model.probB[i] = atof(st.NextToken()); } else if (cmd.StartsWith("nr_sv")) { int n = model.nr_class; model.nSV = new int[n]; SupportClass.Tokenizer st = new SupportClass.Tokenizer(arg); for (int i = 0; i < n; i++) model.nSV[i] = atoi(st.NextToken()); } else if (cmd.StartsWith("SV")) { break; } else { System.Console.Error.Write("unknown text in model file\n"); return null; } } // read sv_coef and SV int m = model.nr_class - 1; int l = model.l; model.sv_coef = new double[m][]; for (int i = 0; i < m; i++) { model.sv_coef[i] = new double[l]; } model.SV = new svm_node[l][]; for (int i = 0; i < l; i++) { System.String line = fp.ReadLine(); SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " \t\n\r\f:"); for (int k = 0; k < m; k++) model.sv_coef[k][i] = atof(st.NextToken()); int n = st.Count / 2; model.SV[i] = new svm_node[n]; for (int j = 0; j < n; j++) { model.SV[i][j] = new svm_node(); model.SV[i][j].index = atoi(st.NextToken()); model.SV[i][j].value = atof(st.NextToken()); } } fp.Close(); return model; }
private static void predict(System.IO.StreamReader input, System.IO.BinaryWriter output, svm_model model, int predict_probability) { int correct = 0; int total = 0; double error = 0; double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0; int svm_type = svm.svm_get_svm_type(model); int nr_class = svm.svm_get_nr_class(model); int[] labels = new int[nr_class]; double[] prob_estimates = null; if (predict_probability == 1) { if (svm_type == svm_parameter.EPSILON_SVR || svm_type == svm_parameter.NU_SVR) { System.Console.Out.Write("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=" + svm.svm_get_svr_probability(model) + "\n"); } else { svm.svm_get_labels(model, labels); prob_estimates = new double[nr_class]; //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("labels"); for (int j = 0; j < nr_class; j++) { //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(" " + labels[j]); } //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("\n"); } } while (true) { System.String line = input.ReadLine(); if ((System.Object) line == null) break; SupportClass.Tokenizer st = new SupportClass.Tokenizer(line, " \t\n\r\f:"); double target = atof(st.NextToken()); int m = st.Count / 2; svm_node[] x = new svm_node[m]; for (int j = 0; j < m; j++) { x[j] = new svm_node(); x[j].index = atoi(st.NextToken()); x[j].value = atof(st.NextToken()); } double v; if (predict_probability == 1 && (svm_type == svm_parameter.C_SVC || svm_type == svm_parameter.NU_SVC)) { v = svm.svm_predict_probability(model, x, prob_estimates); //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(v + " "); for (int j = 0; j < nr_class; j++) { //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(prob_estimates[j] + " "); } //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write("\n"); } else { v = svm.svm_predict(model, x); //UPGRADE_ISSUE: Method 'java.io.DataOutputStream.Write' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaioDataOutputStreamWrite_javalangString"' output.Write(v + "\n"); } if (v == target) ++correct; error += (v - target) * (v - target); sumv += v; sumy += target; sumvv += v * v; sumyy += target * target; sumvy += v * target; ++total; } System.Console.Out.Write("Accuracy = " + (double) correct / total * 100 + "% (" + correct + "/" + total + ") (classification)\n"); System.Console.Out.Write("Mean squared error = " + error / total + " (regression)\n"); System.Console.Out.Write("Squared correlation coefficient = " + ((total * sumvy - sumv * sumy) * (total * sumvy - sumv * sumy)) / ((total * sumvv - sumv * sumv) * (total * sumyy - sumy * sumy)) + " (regression)\n"); }
/// <summary> Creates a new CBlkSizeSpec object for the specified number of tiles and /// components and the ParameterList instance. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">the type of the specification module i.e. tile specific, /// component specific or both. /// /// </param> /// <param name="imgsrc">The image source (used to get the image size) /// /// </param> /// <param name="pl">The ParameterList instance /// /// </param> public CBlkSizeSpec(int nt, int nc, byte type, ParameterList pl) : base(nt, nc, type) { bool firstVal = true; System.String param = pl.getParameter(optName); // Precinct partition is used : parse arguments SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification int ci, ti; // i, xIdx removed System.String word = null; // current word System.String errMsg = null; while (stk.HasMoreTokens()) { word = stk.NextToken(); switch (word[0]) { case 't': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_TILE_DEF; } break; case 'c': // Components specification compSpec = parseIdx(word, nComp); if (curSpecType == SPEC_TILE_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_COMP_DEF; } break; default: if (!System.Char.IsDigit(word[0])) { errMsg = "Bad construction for parameter: " + word; throw new System.ArgumentException(errMsg); } System.Int32[] dim = new System.Int32[2]; // Get code-block's width try { dim[0] = System.Int32.Parse(word); // Check that width is not > // StdEntropyCoderOptions.MAX_CB_DIM if (dim[0] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM) { errMsg = "'" + optName + "' option : the code-block's " + "width cannot be greater than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM; throw new System.ArgumentException(errMsg); } // Check that width is not < // StdEntropyCoderOptions.MIN_CB_DIM if (dim[0] < CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM) { errMsg = "'" + optName + "' option : the code-block's " + "width cannot be less than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM; throw new System.ArgumentException(errMsg); } // Check that width is a power of 2 if (dim[0] != (1 << MathUtil.log2(dim[0]))) { errMsg = "'" + optName + "' option : the code-block's " + "width must be a power of 2"; throw new System.ArgumentException(errMsg); } } catch (System.FormatException) { errMsg = "'" + optName + "' option : the code-block's " + "width could not be parsed."; throw new System.ArgumentException(errMsg); } // Get the next word in option try { word = stk.NextToken(); } catch (System.ArgumentOutOfRangeException) { errMsg = "'" + optName + "' option : could not parse the " + "code-block's height"; throw new System.ArgumentException(errMsg); } // Get the code-block's height try { dim[1] = System.Int32.Parse(word); // Check that height is not > // StdEntropyCoderOptions.MAX_CB_DIM if (dim[1] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM) { errMsg = "'" + optName + "' option : the code-block's " + "height cannot be greater than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_DIM; throw new System.ArgumentException(errMsg); } // Check that height is not < // StdEntropyCoderOptions.MIN_CB_DIM if (dim[1] < CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM) { errMsg = "'" + optName + "' option : the code-block's " + "height cannot be less than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MIN_CB_DIM; throw new System.ArgumentException(errMsg); } // Check that height is a power of 2 if (dim[1] != (1 << MathUtil.log2(dim[1]))) { errMsg = "'" + optName + "' option : the code-block's " + "height must be a power of 2"; throw new System.ArgumentException(errMsg); } // Check that the code-block 'area' (i.e. width*height) is // not greater than StdEntropyCoderOptions.MAX_CB_AREA if (dim[0] * dim[1] > CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_AREA) { errMsg = "'" + optName + "' option : The " + "code-block's area (i.e. width*height) " + "cannot be greater than " + CSJ2K.j2k.entropy.StdEntropyCoderOptions.MAX_CB_AREA; throw new System.ArgumentException(errMsg); } } catch (System.FormatException) { errMsg = "'" + optName + "' option : the code-block's height " + "could not be parsed."; throw new System.ArgumentException(errMsg); } // Store the maximum dimensions if necessary if (dim[0] > maxCBlkWidth) { maxCBlkWidth = dim[0]; } if (dim[1] > maxCBlkHeight) { maxCBlkHeight = dim[1]; } if (firstVal) { // This is the first time a value is given so we set it as // the default one setDefault((System.Object)(dim)); firstVal = false; } switch (curSpecType) { case SPEC_DEF: setDefault((System.Object)(dim)); break; case SPEC_TILE_DEF: for (ti = tileSpec.Length - 1; ti >= 0; ti--) { if (tileSpec[ti]) { setTileDef(ti, (System.Object)(dim)); } } break; case SPEC_COMP_DEF: for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (compSpec[ci]) { setCompDef(ci, (System.Object)(dim)); } } break; default: for (ti = tileSpec.Length - 1; ti >= 0; ti--) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (tileSpec[ti] && compSpec[ci]) { setTileCompVal(ti, ci, (System.Object)(dim)); } } } break; } break; } // end switch } }
/// <summary> Constructs a new 'ForwCompTransfSpec' for the specified number of /// components and tiles, the wavelet filters type and the parameter of the /// option 'Mct'. This constructor is called by the encoder. It also checks /// that the arguments belong to the recognized arguments list. /// /// <p>This constructor chose the component transformation type depending /// on the wavelet filters : RCT with w5x3 filter and ICT with w9x7 /// filter. Note: All filters must use the same data type.</p> /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">the type of the specification module i.e. tile specific, /// component specific or both. /// /// </param> /// <param name="wfs">The wavelet filter specifications /// /// </param> /// <param name="pl">The ParameterList /// /// </param> public ForwCompTransfSpec(int nt, int nc, byte type, AnWTFilterSpec wfs, ParameterList pl):base(nt, nc, type) { System.String param = pl.getParameter("Mct"); if (param == null) { // The option has not been specified // If less than three component, do not use any component // transformation if (nc < 3) { setDefault("none"); return ; } // If the compression is lossless, uses RCT else if (pl.getBooleanParameter("lossless")) { setDefault("rct"); return ; } else { AnWTFilter[][] anfilt; int[] filtType = new int[nComp]; for (int c = 0; c < 3; c++) { anfilt = (AnWTFilter[][]) wfs.getCompDef(c); filtType[c] = anfilt[0][0].FilterType; } // Check that the three first components use the same filters bool reject = false; for (int c = 1; c < 3; c++) { if (filtType[c] != filtType[0]) reject = true; } if (reject) { setDefault("none"); } else { anfilt = (AnWTFilter[][]) wfs.getCompDef(0); if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7) { setDefault("ict"); } else { setDefault("rct"); } } } // Each tile receives a component transform specification // according the type of wavelet filters that are used by the // three first components for (int t = 0; t < nt; t++) { AnWTFilter[][] anfilt; int[] filtType = new int[nComp]; for (int c = 0; c < 3; c++) { anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, c); filtType[c] = anfilt[0][0].FilterType; } // Check that the three components use the same filters bool reject = false; for (int c = 1; c < nComp; c++) { if (filtType[c] != filtType[0]) reject = true; } if (reject) { setTileDef(t, "none"); } else { anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, 0); if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7) { setTileDef(t, "ict"); } else { setTileDef(t, "rct"); } } } return ; } // Parse argument SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); System.String word; // current word byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the // specification //System.Boolean value_Renamed; while (stk.HasMoreTokens()) { word = stk.NextToken(); switch (word[0]) { case 't': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_TILE_DEF; } break; case 'c': // Components specification throw new System.ArgumentException("Component specific " + " parameters" + " not allowed with " + "'-Mct' option"); default: if (word.Equals("off")) { if (curSpecType == SPEC_DEF) { setDefault("none"); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) if (tileSpec[i]) { setTileDef(i, "none"); } } } else if (word.Equals("on")) { if (nc < 3) { throw new System.ArgumentException("Cannot use component" + " transformation on a " + "image with less than " + "three components"); } if (curSpecType == SPEC_DEF) { // Set arbitrarily the default // value to RCT (later will be found the suitable // component transform for each tile) setDefault("rct"); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) { if (tileSpec[i]) { if (getFilterType(i, wfs) == CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3) { setTileDef(i, "rct"); } else { setTileDef(i, "ict"); } } } } } else { throw new System.ArgumentException("Default parameter of " + "option Mct not" + " recognized: " + param); } // Re-initialize curSpecType = SPEC_DEF; tileSpec = null; break; } } // Check that default value has been specified if (getDefault() == null) { // If not, set arbitrarily the default value to 'none' but // specifies explicitely a default value for each tile depending // on the wavelet transform that is used setDefault("none"); for (int t = 0; t < nt; t++) { if (isTileSpecified(t)) { continue; } AnWTFilter[][] anfilt; int[] filtType = new int[nComp]; for (int c = 0; c < 3; c++) { anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, c); filtType[c] = anfilt[0][0].FilterType; } // Check that the three components use the same filters bool reject = false; for (int c = 1; c < nComp; c++) { if (filtType[c] != filtType[0]) reject = true; } if (reject) { setTileDef(t, "none"); } else { anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, 0); if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7) { setTileDef(t, "ict"); } else { setTileDef(t, "rct"); } } } } // Check validity of component transformation of each tile compared to // the filter used. for (int t = nt - 1; t >= 0; t--) { if (((System.String) getTileDef(t)).Equals("none")) { // No comp. transf is used. No check is needed continue; } else if (((System.String) getTileDef(t)).Equals("rct")) { // Tile is using Reversible component transform int filterType = getFilterType(t, wfs); switch (filterType) { case CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3: // OK break; case CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7: // Must use ICT if (isTileSpecified(t)) { // User has requested RCT -> Error throw new System.ArgumentException("Cannot use RCT " + "with 9x7 filter " + "in tile " + t); } else { // Specify ICT for this tile setTileDef(t, "ict"); } break; default: throw new System.ArgumentException("Default filter is " + "not JPEG 2000 part" + " I compliant"); } } else { // ICT int filterType = getFilterType(t, wfs); switch (filterType) { case CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3: // Must use RCT if (isTileSpecified(t)) { // User has requested ICT -> Error throw new System.ArgumentException("Cannot use ICT " + "with filter 5x3 " + "in tile " + t); } else { setTileDef(t, "rct"); } break; case CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7: // OK break; default: throw new System.ArgumentException("Default filter is " + "not JPEG 2000 part" + " I compliant"); } } } }
/// <summary> Creates a new PrecinctSizeSpec object for the specified number of tiles /// and components and the ParameterList instance. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="type">the type of the specification module i.e. tile specific, /// component specific or both. /// /// </param> /// <param name="imgsrc">The image source (used to get the image size) /// /// </param> /// <param name="pl">The ParameterList instance /// /// </param> public PrecinctSizeSpec(int nt, int nc, byte type, BlkImgDataSrc imgsrc, IntegerSpec dls, ParameterList pl):base(nt, nc, type) { this.dls = dls; // The precinct sizes are stored in a 2 elements vector array, the // first element containing a vector for the precincts width for each // resolution level and the second element containing a vector for the // precincts height for each resolution level. The precincts sizes are // specified from the highest resolution level to the lowest one // (i.e. 0). If there are less elements than the number of // decomposition levels, the last element is used for all remaining // resolution levels (i.e. if the precincts sizes are specified only // for resolutions levels 5, 4 and 3, then the precincts size for // resolution levels 2, 1 and 0 will be the same as the size used for // resolution level 3). // Boolean used to know if we were previously reading a precinct's // size or if we were reading something else. bool wasReadingPrecinctSize = false; System.String param = pl.getParameter(optName); // Set precinct sizes to default i.e. 2^15 = // Markers.PRECINCT_PARTITION_DEF_SIZE System.Collections.ArrayList[] tmpv = new System.Collections.ArrayList[2]; tmpv[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppx tmpv[0].Add((System.Int32) CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE); tmpv[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppy tmpv[1].Add((System.Int32) CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE); setDefault(tmpv); if (param == null) { // No precinct size specified in the command line so we do not try // to parse it. return ; } // Precinct partition is used : parse arguments SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification bool[] compSpec = null; // Components concerned by the specification int ci, ti; //i, xIdx removed bool endOfParamList = false; System.String word = null; // current word System.Int32 w, h; System.String errMsg = null; while ((stk.HasMoreTokens() || wasReadingPrecinctSize) && !endOfParamList) { System.Collections.ArrayList[] v = new System.Collections.ArrayList[2]; // v[0] : ppx, v[1] : ppy // We do not read the next token if we were reading a precinct's // size argument as we have already read the next token into word. if (!wasReadingPrecinctSize) { word = stk.NextToken(); } wasReadingPrecinctSize = false; switch (word[0]) { case 't': // Tiles specification tileSpec = parseIdx(word, nTiles); if (curSpecType == SPEC_COMP_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_TILE_DEF; } break; case 'c': // Components specification compSpec = parseIdx(word, nComp); if (curSpecType == SPEC_TILE_DEF) { curSpecType = SPEC_TILE_COMP; } else { curSpecType = SPEC_COMP_DEF; } break; default: if (!System.Char.IsDigit(word[0])) { errMsg = "Bad construction for parameter: " + word; throw new System.ArgumentException(errMsg); } // Initialises Vector objects v[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppx v[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppy while (true) { // Now get the precinct dimensions try { // Get precinct width w = System.Int32.Parse(word); // Get next word in argument list try { word = stk.NextToken(); } catch (System.ArgumentOutOfRangeException) { errMsg = "'" + optName + "' option : could not " + "parse the precinct's width"; throw new System.ArgumentException(errMsg); } // Get precinct height h = System.Int32.Parse(word); if (w != (1 << MathUtil.log2(w)) || h != (1 << MathUtil.log2(h))) { errMsg = "Precinct dimensions must be powers of 2"; throw new System.ArgumentException(errMsg); } } catch (System.FormatException) { errMsg = "'" + optName + "' option : the argument '" + word + "' could not be parsed."; throw new System.ArgumentException(errMsg); } // Store packet's dimensions in Vector arrays v[0].Add(w); v[1].Add(h); // Try to get the next token if (stk.HasMoreTokens()) { word = stk.NextToken(); if (!System.Char.IsDigit(word[0])) { // The next token does not start with a digit so // it is not a precinct's size argument. We set // the wasReadingPrecinctSize booleen such that we // know that we don't have to read another token // and check for the end of the parameters list. wasReadingPrecinctSize = true; if (curSpecType == SPEC_DEF) { setDefault(v); } else if (curSpecType == SPEC_TILE_DEF) { for (ti = tileSpec.Length - 1; ti >= 0; ti--) { if (tileSpec[ti]) { setTileDef(ti, v); } } } else if (curSpecType == SPEC_COMP_DEF) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (compSpec[ci]) { setCompDef(ci, v); } } } else { for (ti = tileSpec.Length - 1; ti >= 0; ti--) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (tileSpec[ti] && compSpec[ci]) { setTileCompVal(ti, ci, v); } } } } // Re-initialize curSpecType = SPEC_DEF; tileSpec = null; compSpec = null; // Go back to 'normal' parsing break; } else { // Next token starts with a digit so read it } } else { // We have reached the end of the parameters list so // we store the last precinct's sizes and we stop if (curSpecType == SPEC_DEF) { setDefault(v); } else if (curSpecType == SPEC_TILE_DEF) { for (ti = tileSpec.Length - 1; ti >= 0; ti--) { if (tileSpec[ti]) { setTileDef(ti, v); } } } else if (curSpecType == SPEC_COMP_DEF) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (compSpec[ci]) { setCompDef(ci, v); } } } else { for (ti = tileSpec.Length - 1; ti >= 0; ti--) { for (ci = compSpec.Length - 1; ci >= 0; ci--) { if (tileSpec[ti] && compSpec[ci]) { setTileCompVal(ti, ci, v); } } } } endOfParamList = true; break; } } // while (true) break; } // switch } // while }
/// <param name="theMessage">an HL7 message from which data are to be queried /// </param> /// <param name="theQuery">the query (see class docs for syntax) /// </param> /// <returns> data from the message that are selected by the query /// </returns> public static NuGenMessageQuery.Result query(Message theMessage, System.String theQuery) { System.Collections.Specialized.NameValueCollection clauses = getClauses(theQuery); //parse select clause SupportClass.Tokenizer select = new SupportClass.Tokenizer(clauses.Get("select"), ", ", false); System.Collections.ArrayList fieldPaths = new System.Collections.ArrayList(10); System.Collections.Hashtable names = new System.Collections.Hashtable(10); while (select.HasMoreTokens()) { System.String token = select.NextToken(); if (token.Equals("as")) { if (!select.HasMoreTokens()) { throw new System.ArgumentException("Keyword 'as' must be followed by a field label"); } names[select.NextToken()] = (System.Int32) (fieldPaths.Count - 1); } else { fieldPaths.Add(token); } } //parse loop clause SupportClass.Tokenizer loop = new SupportClass.Tokenizer(clauses["loop"] == null?"":clauses["loop"], ",", false); System.Collections.ArrayList loopPoints = new System.Collections.ArrayList(10); System.Collections.Hashtable loopPointNames = new System.Collections.Hashtable(10); while (loop.HasMoreTokens()) { System.String pointDecl = loop.NextToken(); SupportClass.Tokenizer tok = new SupportClass.Tokenizer(pointDecl, "=", false); System.String name = tok.NextToken().Trim(); System.String path = tok.NextToken().Trim(); loopPoints.Add(path); loopPointNames[name] = (System.Int32) (loopPoints.Count - 1); } //parse where clause //TODO: this will do for now but it should really be evaluated like an expression //rather than a list SupportClass.Tokenizer where = new SupportClass.Tokenizer(clauses["where"] == null?"":clauses["where"], ",", false); System.Collections.ArrayList filters = new System.Collections.ArrayList(); while (where.HasMoreTokens()) { filters.Add(where.NextToken()); } System.String[] filterPaths = new System.String[filters.Count]; System.String[] filterPatterns = new System.String[filters.Count]; bool[] exactFlags = new bool[filters.Count]; for (int i = 0; i < filters.Count; i++) { exactFlags[i] = true; System.String filter = (System.String) filters[i]; System.String[] parts = splitFromEnd(filter, "="); if (parts[1] != null) { parts[1] = parts[1].Substring(1); } else { exactFlags[i] = false; parts = splitFromEnd(filter, "like"); parts[1] = parts[1].Substring(4); } filterPaths[i] = parts[0].Trim(); parts[1] = parts[1].Trim(); filterPatterns[i] = parts[1].Substring(1, (parts[1].Length - 1) - (1)); } String[] retVal1 = new String[loopPoints.Count]; loopPoints.CopyTo(retVal1); String[] retVal2 = new String[fieldPaths.Count]; fieldPaths.CopyTo(retVal2); return new ResultImpl(theMessage, retVal1, loopPointNames, retVal2, names, filterPaths, filterPatterns, exactFlags); }
/// <summary> Creates a new PGX file reader from the specified File object. /// /// </summary> /// <param name="in">The input file as File object. /// /// </param> /// <exception cref="IOException">If an I/O error occurs. /// /// </exception> public ImgReaderPGX(System.IO.FileInfo in_Renamed) { System.String header; // Check if specified file exists bool tmpBool; if (System.IO.File.Exists(in_Renamed.FullName)) { tmpBool = true; } else { tmpBool = System.IO.Directory.Exists(in_Renamed.FullName); } if (!tmpBool) { throw new System.ArgumentException("PGX file " + in_Renamed.Name + " does not exist"); } //Opens the given file this.in_Renamed = SupportClass.RandomAccessFileSupport.CreateRandomAccessFile(in_Renamed, "r"); try { System.IO.StreamReader in_reader = new System.IO.StreamReader(this.in_Renamed); //UPGRADE_ISSUE: Method 'java.io.RandomAccessFile.readLine' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javaioRandomAccessFilereadLine'" header = in_reader.ReadLine(); } catch (System.IO.IOException) { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } if (header == null) { throw new System.IO.IOException(in_Renamed.Name + " is an empty file"); } offset = (header.Length + 1); //Get informations from header SupportClass.Tokenizer st = new SupportClass.Tokenizer(header); try { int nTokens = st.Count; // Magic Number if (!(st.NextToken()).Equals("PG")) { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } // Endianess System.String tmp = st.NextToken(); if (tmp.Equals("LM")) { byteOrder = CSJ2K.j2k.io.EndianType_Fields.LITTLE_ENDIAN; } else if (tmp.Equals("ML")) { byteOrder = CSJ2K.j2k.io.EndianType_Fields.BIG_ENDIAN; } else { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } // Unsigned/signed if present in the header if (nTokens == 6) { tmp = st.NextToken(); if (tmp.Equals("+")) { isSigned = false; } else if (tmp.Equals("-")) { isSigned = true; } else { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } } // bit-depth, width, height try { bitDepth = (System.Int32.Parse(st.NextToken())); // bitDepth must be between 1 and 31 if ((bitDepth <= 0) || (bitDepth > 31)) { throw new System.IO.IOException(in_Renamed.Name + " is not a valid PGX file"); } w = (System.Int32.Parse(st.NextToken())); h = (System.Int32.Parse(st.NextToken())); } catch (System.FormatException) { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } } catch (System.ArgumentOutOfRangeException) { throw new System.IO.IOException(in_Renamed.Name + " is not a PGX file"); } // Number of component nc = 1; // Number of bytes per data if (bitDepth <= 8) { packBytes = 1; } else if (bitDepth <= 16) { packBytes = 2; } // <= 31 else { packBytes = 4; } }
//extracts LP# of label between first '{' and first '}', or -1 if there isn't one private int getLoopPointReference(System.String thePath) { SupportClass.Tokenizer tok = new SupportClass.Tokenizer(thePath, "{}", false); if (thePath.IndexOf('{') >= 0 && tok.HasMoreTokens()) { System.String ref_Renamed = tok.NextToken(); return ((System.Int32) myLoopPointNames[ref_Renamed]); } else { return - 1; } }
/// <summary> Creates a new ProgressionSpec object for the specified number of tiles, /// components and the ParameterList instance. /// /// </summary> /// <param name="nt">The number of tiles /// /// </param> /// <param name="nc">The number of components /// /// </param> /// <param name="nl">The number of layer /// /// </param> /// <param name="dls">The number of decomposition levels specifications /// /// </param> /// <param name="type">the type of the specification module. The ProgressionSpec /// class should only be used only with the type ModuleSpec.SPEC_TYPE_TILE. /// /// </param> /// <param name="pl">The ParameterList instance /// /// </param> public ProgressionSpec(int nt, int nc, int nl, IntegerSpec dls, byte type, ParameterList pl) : base(nt, nc, type) { System.String param = pl.getParameter("Aptype"); Progression[] prog; int mode = -1; if (param == null) { // No parameter specified if (pl.getParameter("Rroi") == null) { mode = checkProgMode("res"); } else { mode = checkProgMode("layer"); } if (mode == -1) { System.String errMsg = "Unknown progression type : '" + param + "'"; throw new System.ArgumentException(errMsg); } prog = new Progression[1]; prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl); setDefault(prog); return; } SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param); byte curSpecType = SPEC_DEF; // Specification type of the // current parameter bool[] tileSpec = null; // Tiles concerned by the specification System.String word = null; // current word System.String errMsg2 = null; // Error message bool needInteger = false; // True if an integer value is expected int intType = 0; // Type of read integer value (0=index of first // resolution level, 1= index of first component, 2=index of first // layer not included, 3= index of first resolution level not // included, 4= index of first component not included System.Collections.ArrayList progression = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); int tmp = 0; Progression curProg = null; while (stk.HasMoreTokens()) { word = stk.NextToken(); switch (word[0]) { case 't': // If progression were previously found, store them if (progression.Count > 0) { // Ensure that all information has been taken curProg.ce = nc; curProg.lye = nl; curProg.re = dls.Max + 1; prog = new Progression[progression.Count]; progression.CopyTo(prog); if (curSpecType == SPEC_DEF) { setDefault(prog); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) { if (tileSpec[i]) { setTileDef(i, prog); } } } } progression.Clear(); intType = -1; needInteger = false; // Tiles specification tileSpec = parseIdx(word, nTiles); curSpecType = SPEC_TILE_DEF; break; default: // Here, words is either a Integer (progression bound index) // or a String (progression order type). This is determined by // the value of needInteger. if (needInteger) { // Progression bound info try { tmp = (System.Int32.Parse(word)); } catch (System.FormatException) { // Progression has missing parameters throw new System.ArgumentException("Progression " + "order" + " specification " + "has missing " + "parameters: " + param); } switch (intType) { case 0: // cs if (tmp < 0 || tmp > (dls.Max + 1)) { throw new System.ArgumentException("Invalid res_start " + "in '-Aptype'" + " option: " + tmp); } curProg.rs = tmp; break; case 1: // rs if (tmp < 0 || tmp > nc) { throw new System.ArgumentException("Invalid comp_start " + "in '-Aptype' " + "option: " + tmp); } curProg.cs = tmp; break; case 2: // lye if (tmp < 0) { throw new System.ArgumentException("Invalid layer_end " + "in '-Aptype'" + " option: " + tmp); } if (tmp > nl) { tmp = nl; } curProg.lye = tmp; break; case 3: // ce if (tmp < 0) { throw new System.ArgumentException("Invalid res_end " + "in '-Aptype'" + " option: " + tmp); } if (tmp > (dls.Max + 1)) { tmp = dls.Max + 1; } curProg.re = tmp; break; case 4: // re if (tmp < 0) { throw new System.ArgumentException("Invalid comp_end " + "in '-Aptype'" + " option: " + tmp); } if (tmp > nc) { tmp = nc; } curProg.ce = tmp; break; } if (intType < 4) { intType++; needInteger = true; break; } else if (intType == 4) { intType = 0; needInteger = false; break; } else { throw new System.ApplicationException("Error in usage of 'Aptype' " + "option: " + param); } } if (!needInteger) { // Progression type info mode = checkProgMode(word); if (mode == -1) { errMsg2 = "Unknown progression type : '" + word + "'"; throw new System.ArgumentException(errMsg2); } needInteger = true; intType = 0; if (progression.Count == 0) { curProg = new Progression(mode, 0, nc, 0, dls.Max + 1, nl); } else { curProg = new Progression(mode, 0, nc, 0, dls.Max + 1, nl); } progression.Add(curProg); } break; } // switch } // while if (progression.Count == 0) { // No progression defined if (pl.getParameter("Rroi") == null) { mode = checkProgMode("res"); } else { mode = checkProgMode("layer"); } if (mode == -1) { errMsg2 = "Unknown progression type : '" + param + "'"; throw new System.ArgumentException(errMsg2); } prog = new Progression[1]; prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl); setDefault(prog); return; } // Ensure that all information has been taken curProg.ce = nc; curProg.lye = nl; curProg.re = dls.Max + 1; // Store found progression prog = new Progression[progression.Count]; progression.CopyTo(prog); if (curSpecType == SPEC_DEF) { setDefault(prog); } else if (curSpecType == SPEC_TILE_DEF) { for (int i = tileSpec.Length - 1; i >= 0; i--) { if (tileSpec[i]) { setTileDef(i, prog); } } } // Check that default value has been specified if (getDefault() == null) { int ndefspec = 0; for (int t = nt - 1; t >= 0; t--) { for (int c = nc - 1; c >= 0; c--) { if (specValType[t][c] == SPEC_DEF) { ndefspec++; } } } // If some tile-component have received no specification, they // receive the default progressiveness. if (ndefspec != 0) { if (pl.getParameter("Rroi") == null) { mode = checkProgMode("res"); } else { mode = checkProgMode("layer"); } if (mode == -1) { errMsg2 = "Unknown progression type : '" + param + "'"; throw new System.ArgumentException(errMsg2); } prog = new Progression[1]; prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl); setDefault(prog); } else { // All tile-component have been specified, takes the first // tile-component value as default. setDefault(getTileCompVal(0, 0)); switch (specValType[0][0]) { case SPEC_TILE_DEF: for (int c = nc - 1; c >= 0; c--) { if (specValType[0][c] == SPEC_TILE_DEF) { specValType[0][c] = SPEC_DEF; } } tileDef[0] = null; break; case SPEC_COMP_DEF: for (int t = nt - 1; t >= 0; t--) { if (specValType[t][0] == SPEC_COMP_DEF) { specValType[t][0] = SPEC_DEF; } } compDef[0] = null; break; case SPEC_TILE_COMP: specValType[0][0] = SPEC_DEF; tileCompVal["t0c0"] = null; break; } } } }
/// <summary> Write COM marker segment(s) to the codestream. /// /// <p>This marker is currently written in main header and indicates the /// JJ2000 encoder's version that has created the codestream.</p> /// /// </summary> private void writeCOM() { // JJ2000 COM marker segment if (enJJ2KMarkSeg) { System.String str = "Created by: CSJ2K version " + JJ2KInfo.version; int markSegLen; // the marker segment length // COM marker hbuf.Write((System.Int16) CSJ2K.j2k.codestream.Markers.COM); // Calculate length: Lcom(2) + Rcom (2) + string's length; markSegLen = 2 + 2 + str.Length; hbuf.Write((System.Int16) markSegLen); // Rcom hbuf.Write((System.Int16) 1); // General use (IS 8859-15:1999(Latin) values) byte[] chars = System.Text.Encoding.UTF8.GetBytes(str); for (int i = 0; i < chars.Length; i++) { hbuf.Write((byte) chars[i]); } } // other COM marker segments if (otherCOMMarkSeg != null) { SupportClass.Tokenizer stk = new SupportClass.Tokenizer(otherCOMMarkSeg, "#"); while (stk.HasMoreTokens()) { System.String str = stk.NextToken(); int markSegLen; // the marker segment length // COM marker hbuf.Write((System.Int16) CSJ2K.j2k.codestream.Markers.COM); // Calculate length: Lcom(2) + Rcom (2) + string's length; markSegLen = 2 + 2 + str.Length; hbuf.Write((System.Int16) markSegLen); // Rcom hbuf.Write((System.Int16) 1); // General use (IS 8859-15:1999(Latin) // values) byte[] chars = System.Text.Encoding.UTF8.GetBytes(str); for (int i = 0; i < chars.Length; i++) { hbuf.Write((byte) chars[i]); } } } }