示例#1
0
    Node create(Node parent, Document doc) throws ThinklabException {

      Node ret = doc.createElement(tag);

      if (attrs != null)
        for (Pair<String, String> a : attrs) {
          Attr attr = doc.createAttribute(a.getFirst());
          attr.setValue(a.getSecond());
          ((Element) ret).setAttributeNode(attr);
        }

      for (Object o : contents) {

        if (o instanceof String) {
          String text = (String) o;
          XMLDocument.setTextContent(doc, ret, text);
        } else if (o instanceof Collection<?>) {
          for (Iterator<?> it = ((Collection<?>) o).iterator(); it.hasNext(); ) {
            Object no = it.next();
            if (!(no instanceof XmlNode)) {
              throw new ThinklabValidationException("XML.node: collections must be of XmlNode");
            }
            ret.appendChild(((XmlNode) no).create(ret, doc));
          }
        } else if (o instanceof XmlNode) {
          ret.appendChild(((XmlNode) o).create(ret, doc));
        }
      }

      return ret;
    }
示例#2
0
    void define(Node self, Document doc) throws ThinklabException {

      if (attrs != null)
        for (Pair<String, String> a : attrs) {
          Attr attr = doc.createAttribute(a.getFirst());
          attr.setValue(a.getSecond());
          ((Element) self).setAttributeNode(attr);
        }

      for (Object o : contents) {

        if (o instanceof String) {
          String text = (String) o;
          XMLDocument.setTextContent(doc, self, text);
        } else if (o instanceof Collection<?>) {
          for (Iterator<?> it = ((Collection<?>) o).iterator(); it.hasNext(); ) {
            Object no = it.next();
            if (no instanceof XmlNode) {
              self.appendChild(((XmlNode) no).create(self, doc));
            } else if (no instanceof Polylist) {
              self.appendChild(((Polylist) no).createXmlNode().create(self, doc));
            } else {
              throw new ThinklabValidationException(
                  "XML.node: collections must be of XmlNode or Polylist");
            }
          }
        } else if (o instanceof XmlNode) {
          self.appendChild(((XmlNode) o).create(self, doc));
        } else if (o instanceof Polylist) {
          self.appendChild(((Polylist) o).createXmlNode().create(self, doc));
        }
      }
    }
示例#3
0
  public void exportKML() throws ThinklabException {

    Pair<String, String> uncu = application.getNewResourceUrl(".kmz", session);
    userModel.getStoryline().export(uncu.getFirst());
    try {
      Filedownload.save(uncu.getSecond(), "application/vnd.google-earth.kmz");
    } catch (FileNotFoundException e) {
      throw new ThinklabIOException(e);
    }
  }
    public Object getValue(int idx, Object[] registers) {

      Object o = super.getValue(idx, registers);
      if (o instanceof Number && Double.isNaN(((Number) o).doubleValue())) o = null;

      if (o == null && !hasNilClassifier) return null;

      for (Pair<GeneralClassifier, IConcept> p : classifiers) {
        if (p.getFirst().classify(o)) {
          /*
           * create distribution, set 100% evidence for classified concept.
           */
          return p.getSecond();
        }
      }
      // null means "no data"; it can be caught using with a nil classifier
      return null;
    }
  @Override
  public void initialize(IInstance i) throws ThinklabException {

    super.initialize(i);

    /*
     * these should be in already through reflection, but let's keep
     * the OWL way supported just in case.
     */
    for (IRelationship r : i.getRelationships("modeltypes:hasClassifier")) {
      String[] rz = r.getValue().toString().split("->");
      Pair<GeneralClassifier, IConcept> cls =
          new Pair<GeneralClassifier, IConcept>(
              new GeneralClassifier(rz[1]), KnowledgeManager.get().requireConcept(rz[0]));
      classifiers.add(cls);
    }

    /*
     * we have no guarantee that the universal classifier, if there,
     * will be last, given that it may come from an OWL multiproperty where
     * the orderding isn't guaranteed.
     *
     * scan the classifiers and if we have a universal classifier make sure
     * it's the last one, to avoid problems.
     */
    int unidx = -1;
    int iz = 0;
    for (Pair<GeneralClassifier, IConcept> cls : classifiers) {
      if (cls.getFirst().isUniversal()) {
        unidx = iz;
      }
      iz++;
    }

    if (unidx >= 0 && unidx < classifiers.size() - 1) {
      ArrayList<Pair<GeneralClassifier, IConcept>> nc =
          new ArrayList<Pair<GeneralClassifier, IConcept>>();
      for (iz = 0; iz < classifiers.size(); iz++) {
        if (iz != unidx) nc.add(classifiers.get(iz));
      }
      nc.add(classifiers.get(unidx));
      classifiers = nc;
    }

    /*
     * check if we have a nil classifier; if we don't we don't bother classifying
     * nulls and save some work.
     */
    this.hasNilClassifier = false;
    for (Pair<GeneralClassifier, IConcept> cl : classifiers) {
      if (cl.getFirst().isNil()) {
        this.hasNilClassifier = true;
        break;
      }
    }

    IValue def = i.get(CoreScience.HAS_CONCEPTUAL_SPACE);
    if (def != null) cSpace = def.getConcept();

    def = i.get("modeltypes:encodesContinuousDistribution");
    if (def != null) continuousDistribution = MiscUtilities.parseDoubleVector(def.toString());

    // TODO remove?
    if (continuousDistribution != null
        && getDataSource() != null
        && (getDataSource() instanceof IState))
      ((IState) getDataSource())
          .getMetadata()
          .put(Metadata.CONTINUOS_DISTRIBUTION_BREAKPOINTS, continuousDistribution);

    if (continuousDistribution != null)
      metadata.put(Metadata.CONTINUOS_DISTRIBUTION_BREAKPOINTS, continuousDistribution);

    if (classifiers != null) {

      metadata.put(Metadata.CLASSIFIERS, classifiers);

      IConcept[] rnk = null;
      /*
       * remap the values to ranks and determine how to rewire the input
       * if necessary, use classifiers instead of lexicographic order to
       * infer the appropriate concept order
       */
      ArrayList<GeneralClassifier> cla = new ArrayList<GeneralClassifier>();
      ArrayList<IConcept> con = new ArrayList<IConcept>();
      for (Pair<GeneralClassifier, IConcept> op : classifiers) {
        cla.add(op.getFirst());
        con.add(op.getSecond());
      }

      Pair<double[], IConcept[]> pd = Metadata.computeDistributionBreakpoints(cSpace, cla, con);
      if (pd != null) {
        if (pd.getSecond()[0] != null) {
          rnk = pd.getSecond();
        }
      }

      HashMap<IConcept, Integer> ranks = null;
      if (rnk == null) {
        ranks = Metadata.rankConcepts(cSpace, metadata);
      } else {
        ranks = Metadata.rankConcepts(cSpace, rnk, metadata);
      }
    }
  }